ich würde ja sagen, dass es da eine funktion in MATH gibt.
Weiß nur nicht welche.
Also vlt erstmal den Hintergrund ...
In der Schule schrieben wir eine Klasse zum Rechnen mit Brüchen.
Damit habe ich auch keine Probleme. Mein Problem ist nun, dass ich immer etwas mehr mache als ich machen müsste. Mir reicht es nicht nur einen Konstruktor mit zwei parametrn für nenner und zähler zu haben, ich will auch aus einer double zahl den Bruch erzeugen können. Dazu muss ich wissen, wieviele nachkommastellen die zahl hat.
bsp. 4,5 wära dann 45/10 bzw 9/2.
ich könnte natürlich auch über eine schleife machen
müsste eigentlich funktionieren. hab ich jetzt nicht getestet, aber sollte tun.
nur da muss es doch nen schönen funktionsaufruf für geben
zudem hab ich noch eine Frage
ist die Programmiereung so in Ordnung?
Weiß nur nicht welche.
Also vlt erstmal den Hintergrund ...
In der Schule schrieben wir eine Klasse zum Rechnen mit Brüchen.
Damit habe ich auch keine Probleme. Mein Problem ist nun, dass ich immer etwas mehr mache als ich machen müsste. Mir reicht es nicht nur einen Konstruktor mit zwei parametrn für nenner und zähler zu haben, ich will auch aus einer double zahl den Bruch erzeugen können. Dazu muss ich wissen, wieviele nachkommastellen die zahl hat.
bsp. 4,5 wära dann 45/10 bzw 9/2.
ich könnte natürlich auch über eine schleife machen
Code:
int k=0;
while( (zahl-(int)zahl)>0 ){
k++;
zahl=zahl*10;
}müsste eigentlich funktionieren. hab ich jetzt nicht getestet, aber sollte tun.
nur da muss es doch nen schönen funktionsaufruf für geben
zudem hab ich noch eine Frage
ist die Programmiereung so in Ordnung?
Code:
public class Bruch {
//globale Variablen
private int zaehler;
private int nenner;
//Konstruktoren
public Bruch(){
zaehler = 0;
nenner = 0;
}
public Bruch(int z,int n){
zaehler = z;
nenner = n;
}
public Bruch(double d){
int k = (int)Math.log10(Math.abs(d));
}
//Methoden (Grudrechenarten)
/**
* Die Methode [i]Prod(Bruch b1,Bruch b2)[/i] multipliziert zwei Brüche.
* @param b1 stellt den ersten Bruch dar.
* @param b2 stellt den zweiten Bruch dar.
*/
public void Prod(Bruch b1,Bruch b2){
zaehler = b1.zaehler*b2.zaehler;
nenner = b1.nenner*b2.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Prod(Bruch b1,int value)[/i] multipliziert einen Bruch mit einem Integer.
* @param b1 stellt den ersten Bruch dar.
* @param value stellt den Integer dar.
*/
public void Prod(Bruch b1,int value){
zaehler = b1.zaehler*value;
nenner = b1.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Quot(Bruch b1,Bruch b2)[/i] dividiert zwei Brüche.
* @param b1 stellt den ersten Bruch dar.
* @param b2 stellt den zweiten Bruch dar.
*/
public void Quot(Bruch b1,Bruch b2){
zaehler = b1.zaehler*b2.nenner;
nenner = b1.nenner*b2.zaehler;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Quot(Bruch b,int value)[/i] dividiert einen Bruch durch einen Integer.
* @param b stellt den ersten Bruch dar.
* @param value stellt den Integer dar.
*/
public void Quot(Bruch b,int value){
zaehler = b.zaehler;
nenner = b.nenner*value;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Quot(int value,Bruch b)[/i] dividiert einen Integer durch einen Bruch.
* @param b stellt den ersten Bruch dar.
* @param value stellt den Integer dar.
*/
public void Quot(int value,Bruch b){
zaehler = value*b.nenner;
nenner = b.zaehler;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Summe(Bruch b1,Bruch b2)[/i] addiert zwei Brüche.
* @param b1 stellt den ersten Bruch dar.
* @param b2 stellt den zweiten Bruch dar.
*/
public void Summe(Bruch b1,Bruch b2){
if(b1.nenner!=b2.nenner){
b1.Skal(b2.nenner);
b2.Skal(b1.nenner);
}
zaehler = b1.zaehler+b2.zaehler;
nenner = b1.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Summe(Bruch b,int value)[/i] addiert einen Bruch mit einen Integer.
* @param b stellt den ersten Bruch dar.
* @param value stellt den Integer dar.
*/
public void Summe(Bruch b,int value){
zaehler = b.zaehler+value*b.nenner;
nenner = b.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Diff(Bruch b1,Bruch b2)[/i] subrahiert zwei Brüche.
* @param b1 stellt den ersten Bruch dar.
* @param b2 stellt den zweiten Bruch dar.
*/
public void Diff(Bruch b1,Bruch b2){
if(b1.nenner!=b2.nenner){
b1.Skal(b2.nenner);
b2.Skal(b1.nenner);
}
zaehler = b1.zaehler-b2.zaehler;
nenner = b1.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Diff(Bruch b,int value)[/i] subtrahiert einen Bruch mit einen Integer.
* @param b stellt den ersten Bruch dar.
* @param value stellt den Integer dar.
*/
public void Diff(Bruch b,int value){
zaehler = b.zaehler-value*b.nenner;
nenner = b.nenner;
this.reduce();
this.checkNenner();
}
/**
* Die Methode [i]Diff(Bruch b,int value)[/i] subtrahiert einen Integer mit einen Bruch.
* @param value stellt den Integer dar.
* @param b stellt den ersten Bruch dar.
*/
public void Diff(int value,Bruch b){
zaehler = value*b.nenner-b.zaehler;
nenner = b.nenner;
this.reduce();
this.checkNenner();
}
//Methoden (Zusatzfunktionen)
/**
* Die Methode [i]Skal(int value)[/i] erweiterten einen Bruch um einen Integer-Wert.
* @param value stellt den Integer dar.
*/
public void Skal(int value){
zaehler = value*zaehler;
nenner = value*nenner;
this.checkNenner();
}
/**
* Die Methode [i]Betrag(Bruch b)[/i] gibt den Dezimalwert eines Bruches zurück.
* @param b stellt den Bruch dar.
* @return gibt den Dezimalwert des Bruches zurück.
*/
public static double Betrag(Bruch b){
return b.zaehler/b.nenner;
}
/**
* Die Methode [i]ggt(int value1, int value2)[/i] gibt den größten gemeinsamen Teiler
* von zwei Integer-Werten zurück.
* @param value1 ist der erste Integer.
* @param value2 ist der zweite Integer.
* @return der ggt.
*/
public static int ggt(int value1, int value2)
{
while(value1!=value2)
{
if(value1>value2)
value1=value1-value2;
else
value2=value2-value1;
}
return value1;
}
/**
* Die Methode [i]reduce()[/i] dient zum kürzen eines Bruches.
*/
public void reduce()
{
int g=ggt(zaehler,nenner);
zaehler=zaehler/g;
nenner=nenner/g;
}
/**
* Die Methode [i]checkNenner()[/i] überprüft ob der Nenner negativ ist.
* Sollte dies der Fall sein, werden die Vorzeichen von Zähler und Nenner invertiert.
*/
public void checkNenner(){
if(nenner<0){
zaehler=-zaehler;
nenner=-nenner;
}
}
//getMethoden
/**
* Die Methode [i]getZaehler()[/i] gibt den Zahler des Bruches zurück.
*/
public int getZaehler(){
return this.zaehler;
}
/**
* Die Methode [i]getNenner()[/i] gibt den Nenner des Bruches zurück.
*/
public int getNenner(){
return this.nenner;
}
//setMethoden
/**
* Die Methode [i]setZaehler(int value)[/i] setzt den Zaehler auf dem übergeben
* Integer-Wert.
* @param value stellt den Wert dar, auf den der Zaehler gesetzt werden soll.
*/
public void setZaehler(int value){
zaehler=value;
}
/**
* Die Methode [i]setNenner(int value)[/i] setzt den Nenner auf dem übergeben
* Integer-Wert.
* @param value stellt den Wert dar, auf den der Nenner gesetzt werden soll.
*/
public void setNenner(int value){
nenner=value;
}
/**
* Die Methode [i]setBruch(int z,int n)[/i] setzt den Bruch auf die Übergebenen Werte.
* @param z steht für den Zaehler
* @param n steht für den Nenner
*/
public void setBruch(int z,int n){
zaehler=z;
nenner=n;
}
}
