Methoden implementieren, Sichtbarkeiten, Brüche

[SchwarzWeiß]

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]

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

 

[SchwarzWeiß]

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]

wir befinden uns ja in der Fraction-Klasse

Jepp. Genau

 

[OPMajor]

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]

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]

Ü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]

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]

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

Zeig mal deine main

 

[JStein52]

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

 

[OPMajor]

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

 

[JStein52]

Egal was ich eingebe.

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

 

[JStein52]

           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]

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]

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]

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

 

[OPMajor]

So?

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

 

[Robat]

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

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

 

[JStein52]

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ß]

Das habe ich ja hier schon geschrieben

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]

Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr.

 

[JStein52]

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ß]

Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr.

Wann musst du es denn abgeben?

 

[OPMajor]

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ß]

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

 

[OPMajor]

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]

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]

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]

Na also, geht doch

 

[SchwarzWeiß]

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]

Hast du dann alle Methoden?

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

 

[OPMajor]

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]

- ggt

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

 

[JStein52]

public double umrechnen()

Wie geht die ?

Edit: ein Tip, es ist ein Einzeiler

 

[OPMajor]

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]

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]

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]

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

 

[JStein52]

kehrwert stimmt !!

 

[JStein52]

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]

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

 

[OPMajor]

 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]

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ß]

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]

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]

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

r = Rest der ganzzahligen Division von a/b.

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

 

[JStein52]

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]

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]

Und jetzt bist du fertig

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

 

[OPMajor]

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?