Methoden implementieren, Sichtbarkeiten, Brüche

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 hat gesagt.:
Java: 
sum.zaehler = commonA.zaehler + commonB.zaehler;
sum.nenner = common;
Zum Vergrößern anklicken....
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.
 
Zuletzt bearbeitet:
JStein52 hat gesagt.:
Ach so, du hast Probleme meine Lösung mit deiner zu vergleichen weil die auch noch einen parameterlosen Konstruktor hat ??
Zum Vergrößern anklicken....
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?
 
OPMajor hat gesagt.:
Also mir zeigt es einen Fehler an,wenn ich den Konstruktor parameterlos lasse.
Zum Vergrößern anklicken....
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:
Code: 
    public String toString() {
        String buffer = zaehler + "/" + nenner;
        return buffer;
    }
dann kannst du in deiner main-Methode schreiben:
Code: 
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
 
Ü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:
Code: 
    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.
 
Bei mir gibt es keine Ausgabe bzw. es heißt, es wird ausgeführt(endlos).
Java: 
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 ;
   }
   }
  
  
*/
Java: 
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();
 
Code: 
           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
 
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.
 
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.
 
Und zum Kürzen eines Bruches kommst du ja noch, damit kannst du jeweils die Ergebnisse von addieren und multiplizieren noch "nachbehandeln"
 
So?
Java: 
 public Fraction multiplizieren(Fraction b) {
  
         Fraction Produkt =  this.zähler / this.nenner; * b.zähler/b.nenner;
       return Produkt;
    }
 
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.
Zum Vergrößern anklicken....
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 hat gesagt.:
Ich glaube, ich schaffe die Aufgabe rechtzeitig nicht mehr
Zum Vergrößern anklicken....
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 !
 
So?
Java: 
    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;
    }
Java: 
      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);
 
Zuletzt bearbeitet:
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.
Zum Vergrößern anklicken....
Hier ist auch noch ein Fehler drin, oder?
Java: 
  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;
    }
 
So:
Code: 
    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
 
Jetzt geht es:
Java: 
  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;
    }
Java: 
 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);
 
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?
 
Das Zauberwort ist casten. Du musst dem Compiler bei der Division sagen dass es sich um double-Werte handeln soll die er dividiert.
Code: 
public  double umrechnenFließkommaZahl() {
    double    umrechnung = (double)this.zähler / (double)this.nenner;  
   
       return umrechnung;
    }
 
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
 
Java: 
 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;
 
Das hier ist eine Standard-ggT die du üerall im Netz findest:
Code: 
    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
 
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
 
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
 
JStein52 hat gesagt.:
Das hier ist eine Standard-ggT die du üerall im Netz findest:
Code: 
    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
Zum Vergrößern anklicken....

r = Rest der ganzzahligen Division von a/b.

Aber mir ist es egal, welcher Algorithmus, solange es funktioniert 😉
 
kürzen:

Code: 
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;
 

Aktuelle Jobs

Neue Themen

Ähnliche Themen

Gute Erklärung zu Objekten / Klassen / Methoden / Sichtbarkeiten auf Deutsch
Antworten: 3
Brüche kürzen mittels Methoden und ggT
Antworten: 15
Netbeans sichtbarkeiten
Antworten: 5
Javadoc Sichtbarkeiten
Antworten: 3
sichtbarkeiten bei jcombobox
Antworten: 8

Zurück
Oben