Methoden implementieren, Sichtbarkeiten, Brüche

[OPMajor]

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

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]

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]

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]

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]

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]

Hast du mal versucht das zu compilieren?

 

[OPMajor]

Hast du mal versucht das zu compilieren?

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

 

[Robat]

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]

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]

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]

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]

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

 

[Robat]

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

Stach mir ins Auge, mehr nicht

 

[OPMajor]

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]

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]

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

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?

   public class Fraction1 {
  
    }

 

[Robat]

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]

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]

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.

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

 

[OPMajor]

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

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]

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]

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]

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

Kannst du mir sagen wie das mit dem Konstruktor aussieht?

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

 

[Robat]

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

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]

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]

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

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

Genau.

 

[JStein52]

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]

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]

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]

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

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]

Muss im Konstruktor nicht auch double hin anstatt int?

Im Gegenteil. Deine Attribute sollten int sein ...

 

[OPMajor]

Im Gegenteil. Deine Attribute sollten int sein ...

okay; habe ich geändert.

 

[JStein52]

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]

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]

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]

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

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]

    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]

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

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

 

[JStein52]

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.

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;
}

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]

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;