Methoden implementieren, Sichtbarkeiten, Brüche

O

OPMajor

Aktives Mitglied
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:
Java: 
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?
 
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.
 
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.
 
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.
Zum Vergrößern anklicken....
Ich war das.
 
Sieht das schon besser aus?
Java: 
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;
   }
  
   }
 
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.
 
So weit bin ich jetzt:
Java: 
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;
   }
 
Ist das besser:
Java: 
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;
   }
   
   }
 
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

Java: 
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
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 😉
 
Wie sieht es damit aus?
Java: 
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 ;
   }
   
   }
 
Diesen Code kann ich zumindest schon compilieren:
Java: 
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
 
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?
 
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.:
Java: 
   public class Fraction1 {
  
    }
Zum Vergrößern anklicken....
 
Zuletzt bearbeitet:
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.
 
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.

Java: 
   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:
Java: 
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
 
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.
Ü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.
Zum Vergrößern anklicken....
Also die Methoden addieren und multiplizieren verändern das Objekt bloß?
 
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?
Zum Vergrößern anklicken....
Kann ich nicht einen Scanner verwenden für die Zahlen?
Ich soll jetzt in einem ganz neuen Fenster eine neue Klasse erstellen, oder?
 
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?
Zum Vergrößern anklicken....
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.
 
OPMajor hat gesagt.:
Ich soll jetzt in einem ganz neuen Fenster eine neue Klasse erstellen, oder?
Zum Vergrößern anklicken....

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.
 
So?
Java: 
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 ;
   }
   
   }
   
   
*/

Java: 
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);
       }
}
 
@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.
 
Java: 
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 ;
   }
   
   }
   
   
*/

Java: 
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();
           
           
           
       }
}
 
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.
 
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 ??
 
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.
Zum Vergrößern anklicken....
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.
 

Anhänge

  • Algorithmus.PNG
    Algorithmus.PNG
    17,5 KB · Aufrufe: 38
  • Algorithmus_.PNG
    Algorithmus_.PNG
    13,3 KB · Aufrufe: 48
Zuletzt bearbeitet:
SchwarzWeiß hat gesagt.:
Genau.
Zum Vergrößern anklicken....
Muss im Konstruktor nicht auch double hin anstatt int?
Java: 
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 ;
   }
  
   }
  
  
*/
 
Dann hast du jetzt einen Konstruktor der Zähler und Nenner als Parameter übergeben kriegt und du weist diese Werte den entsprechenden Attributen zu.
 
Dann geben wir jetzt Gas bevor das Wintersemester um ist. Die Methode addiere sieht dann so aus:

Code: 
public Fraction addiere(Fraction bruch) {
...
...
}

Edit: wie addiert man zwei Brüche ??
 
Java: 
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 ;
   }
  
   }
  
  
*/
Java: 
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();
          
          
          
       }
}
 
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.
 
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.
 
Code: 
    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;
    }


Code: 
    private int hauptNenner(int nenner1, int nenner2) {
        int factor = nenner1;
        while ((nenner1 % nenner2) != 0) {
            nenner1 += factor;
        }
        return nenner1;
    }
Code: 
    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.
 
Java: 
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 ;
   }
   
   }
   
   
*/
Java: 
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();
           
           
           
       }
}
 
OPMajor hat gesagt.:
private int zähler =x;
private int nenner = y;
Zum Vergrößern anklicken....
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);
return ergebnis;
}
Zum Vergrößern anklicken....
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.
 
So?
Java: 
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;
 

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