Bruch

[nata]

Hi leute,
ich muss Bruch schreiben und musste einpaare methoden schreieben,
ich habe eine frage bei eine methode.Ich muss double wert von bruch ausgeben.irgendetwas stimmt nicht bei der methode value()

public class Bruch {
	
	private int zaehler;
	private int nenner;
	
	public Bruch(int zaehler, int nenner ) throws Exception{
		if(nenner == 0){
			throw new Exception("Nenner darf nicht 0 sein");
		}
		this.nenner = nenner;
		this.zaehler = zaehler;
	}
	
	public Bruch addBruch(Bruch other) throws Exception{
		if(other.nenner == 0){
			throw new Exception("nenner darf nicht 0 sein");
		}
		
		int z = this.zaehler * other.nenner + this.nenner * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
	}
	
	public Bruch addNummer(int number) throws Exception{
		int z = this.zaehler  + this.nenner * number ;
		int n = this.nenner ;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
		
	}
	
	public Bruch subBruch(Bruch other) throws Exception{
		if(other.nenner == 0){
			throw new Exception("nenner darf nicht 0 sein");
		}
		
		int z = this.zaehler * other.nenner - this.nenner * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
	}
	
	public Bruch multBruch(Bruch other) throws Exception{
		if(other.nenner == 0){
			throw new Exception("nenner darf nicht 0 sein");
		}
		
		int z = this.zaehler * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
	}

	public Bruch divBruch(Bruch other) throws Exception{
		if(other.nenner == 0){
			throw new Exception("nenner darf nicht 0 sein");
		}
		
		int z = this.zaehler * other.nenner ;
		int n = this.nenner * other.zaehler;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
	}
	
	public double value(){		
		double wert = zaehler / nenner;
		return wert;
	}
	
	public String toString(){
		return zaehler + "/" + nenner ;
	}
}

public class BruchMain {
	
	public static void main(String args[]) {
		
		try {
			Bruch b1 = new Bruch(2,3);
			Bruch b2 = new Bruch(5, 2);
			Bruch b3 = b1.addBruch(b2);
			System.out.println(b3.toString());
			double b4 = b2.value();
			
			System.out.println(b4);
		} catch (Exception e) {
		
			e.printStackTrace();
		}
		
	}

}

 

[eRaaaa]

naja, dein nenner+zähler sind int`s
private int zaehler;
private int nenner;

d.h., das ergebnis in value() bei zahler/nenner = int

schreibs z.b. so: (oder caste auf double)

 public double value(){      
        double wert = 1.0 *zaehler / nenner;
        return wert;
    }

 

[nata]

danke vielmals
es funktioniert hervorragend

ich habe noch eine frage
Verwende das Schlüsselwort assert und erweitere die Klasse Bruch um einem Methode public boolean equals(Bruch other) welche auf Äquivalenz testet

soll ich in der methode vergleichen

public boolean equals(Bruch other){
if(this.nenner == other.nenner && this.zaehler == other.zaehler){
retur true;
}else{
return false;
}
}

 

[nata]

danke vielmals
es funktioniert hervorragend

ich habe noch eine frage
Verwende das Schlüsselwort assert und erweitere die Klasse Bruch um einem Methode public boolean equals(Bruch other) welche auf Äquivalenz testet

soll ich in der methode vergleichen

public boolean equals(Bruch other){
if(this.nenner == other.nenner && this.zaehler == other.zaehler){
retur true;
}else{
return false;
}
}

Frage was schlech gestellt.meine frage lautet ob mein code so implementiert ist wie es i der angabe ist

package bruchVonAldoDap;

public class Bruch {
	
	private int zaehler;
	private int nenner;
	
	public Bruch(int zaehler, int nenner ) throws Exception{
		if(nenner == 0){
			throw new Exception("Nenner darf nicht 0 sein");
		}
		this.nenner = nenner;
		this.zaehler = zaehler;
	}
	
	public Bruch addBruch(Bruch other) throws Exception{
		if(other == null){
			throw new Exception("Bruch darf nicht null sein");
		}
		
		int z = this.zaehler * other.nenner + this.nenner * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
			
		return ausgabeBruch;
		
	}
	
	public Bruch addNummer(int number) throws Exception{
		int z = this.zaehler  + this.nenner * number ;
		int n = this.nenner ;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		ausgabeBruch.nenner = n;
		ausgabeBruch.zaehler = z;
		
		return ausgabeBruch;
		
		
	}
	
	public Bruch subBruch(Bruch other) throws Exception{
		if(other == null){
			throw new Exception("Bruch darf nicht null sein");
		}
		
		int z = this.zaehler * other.nenner - this.nenner * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
				
		return ausgabeBruch;
		
	}
	
	public Bruch multBruch(Bruch other) throws Exception{
		if(other == null){
			throw new Exception("Bruch darf nicht null sein");
		}
		
		int z = this.zaehler * other.zaehler ;
		int n = this.nenner * other.nenner;
		
		Bruch ausgabeBruch = new Bruch(z, n);
				
		return ausgabeBruch;
		
	}

	public Bruch divBruch(Bruch other) throws Exception{
		if(other == null){
			throw new Exception("Bruch darf nicht null sein");
		}
		
		int z = this.zaehler * other.nenner ;
		int n = this.nenner * other.zaehler;
		
		Bruch ausgabeBruch = new Bruch(z, n);
		
		return ausgabeBruch;
		
	}
	
	
	public void kuerzen(){
		int z = Math.abs(zaehler);
		int n = Math.abs(nenner);
		while (z != n) {
			if (z > n)
				z = z - n;
			else {
				n = n - z;
			}
		}
		
		zaehler /= n;
		nenner /= n;
	}	
	
	public boolean equals(Bruch other){
		if(this.nenner == other.nenner && this.zaehler == other.zaehler){
			return true;
			
		}else{
			return false;
			}
		}
	
	public double value(){		
		double wert = 1.0 * zaehler / nenner;
		return wert;
	}
	
	public String toString(){
		return zaehler + "/" + nenner ;
	}
}

mich interesiert besonderen equals methode

 

[eRaaaa]

na da fehlt ja zumindestens schonmal das assert-schlüsselwort oder?
Galileo Computing :: Java ist auch eine Insel (8. Auflage) – 8.6 Assertions

 

[nata]

ich weiß, habe auch gelessen wegen assert, aber habe nicht verstanden. für mich ist irgendwie das buch kompliziert geschrieben
wenn wir in der angabe assert ausschliessen wäre meine lösung richtig?

 

[eRaaaa]

denke schon ja

/edit: bzw, kommt natürlich drauf an wie mans sieht: 2/4 equals 1/2 ? normal schon, bei dir nicht. keine ahnung wie dein lehrer sich das nun vorstellt ;/

 

[dbohnen]

ich stehe vor derselben aufgabe und weiß aber nicht, wie ich es schaffe, das er das ergebnis gekürzt ausgibt.
jmd dazu eine idee?
mfg dbohnen

 

[Gast2]

Sollte mit dem größten gemeinsamen Teiler von Zähler und Nenner gehen.

 

[dbohnen]

Habe immer noch das Problem mit dem kürzen.
Ich habe das mal so programmiert, wie ich mir das denke. Aber ich bekomm Fehler. ;(
Ich habe einmal die Klasse Bruch und einmal die Klasse Main.

Bruch.java

public class Bruch {
 
private int zaehler;
private int nenner;
    
    //Definition eines Bruches
    public Bruch(int zaehler, int nenner ) throws Exception{
        if(nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
        this.nenner = nenner;
        this.zaehler = zaehler;
    }
    
    public Bruch AdditionBruch(Bruch zweiterBruch) throws Exception{
        if(zweiterBruch.nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
         
        int z = this.zaehler * zweiterBruch.nenner + this.nenner * zweiterBruch.zaehler;
        int n = this.nenner * zweiterBruch.nenner;
        
        Bruch ausgabeBruch = new Bruch(z, n);
        
        ausgabeBruch.nenner = n;
        ausgabeBruch.zaehler = z;
        
        return ausgabeBruch;
    }
    
 
    //Bruch kuerzen...FUNZT NICHT !!!??? kp warum?
    public double gekBruch (int zaehler, int nenner) {
    if (zaehler == nenner) {
		return nenner;
	}
	else if (zaehler < nenner) {
		return gekBruch(zaehler, nenner - zaehler);
	}else {
		return gekBruch(zaehler - nenner, nenner);
	 }
  }    
    
    //Bruch multiplizieren
    public Bruch MultiplikationBruch(Bruch zweiterBruch) throws Exception{
        if(zweiterBruch.nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
        
        int z = this.zaehler * zweiterBruch.zaehler ;
        int n = this.nenner * zweiterBruch.nenner;
        
        Bruch ausgabeBruch = new Bruch(z, n);
        
        ausgabeBruch.nenner = n;
        ausgabeBruch.zaehler = z;
        
        return ausgabeBruch;
        
    }
}

Main.java

public class Main {
public static void main(String args[]) {
        
        try {
            Bruch b1 = new Bruch(1,2);
            Bruch b2 = new Bruch(1,4);
            Bruch b3 = b1.AdditionBruch(b2);

       //FEHLER: The method toString() in the type Bruch is not applicable for the arguments (Bruch)
            Bruch gekBruch = b3.toString(gekBruch);
			System.out.println("Additionsergebnis: " + b3.toString());
            
            
            Bruch b4 = b1.MultiplikationBruch(b2);
            System.out.println("Multiplikationsergebnis: " + b4.toString());

        } catch (Exception e) {
        
            e.printStackTrace();
        }
    }
}

Mein Ergebnis wird aber leider nicht gekürzt, sondern er gibt halt, beim addieren als Nenner immer:
this.nenner * zweiterBruch.nenner

Für Hilfe bezüglich des Kürzens bin ich dankbar.
mfg dbohnen

 

[SlaterB]

gekBruch wird nirgendwo aufgerufen, oder?

was soll die Methode überhaupt machen,
wenn man ihr 5/5 übergibt ist der Rückgabewert 5, was bedeutet das?
- die Zahl 5,
- Zähler 5 bei welchem Nenner
- Nenner 5 bei welchem Zähler
?

erstmal brauch man doch ein Konzept,
z.B. könnte die Methode kuerze() lauten, gar nix zurückgeben, Parameter sowieso nicht,
sondern sich zaehler und nenner des eigenen Bruch-Objektes anschauen und ändern, ohne die dargestellte Zahl selber zu ändern

aus 5/5 wird dann 1/1,

aus 12/3 wird nicht 9/3 oder was immer du in der Rekursion hast, sondern 4/1,
es gilt, gemeinsame Teiler zu finden dann dann SOWOHL beim nenner ALS AUCH beim zaehler zu kürzen,

eine Methode wie ggt/ größter gemeinsamer Teiler wäre hilfreich, kennst du vielleicht, sonst bei google suchen,
häufige Java-Übungsaufgabe und danach sieht dein Rekursionscode ja ungefähr aus

 

[dbohnen]

So ich bin ein bisschen weiter gekommen...
Jetzt kürzt das Programm die Ergebnisse, wie es soll, nur die Multiplikation macht jetzt noch zicken!

Bruch.java

public class Bruch {
 
private int zaehler;
private int nenner;
    
    //Definition eines Bruches
    public Bruch(int zaehler, int nenner ) throws Exception{
        if(nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
        this.nenner = nenner;
        this.zaehler = zaehler;
    }
    
    public void AdditionBruch(Bruch zweiterBruch) throws Exception{
        if(zweiterBruch.nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
        
        zaehler = zaehler*zweiterBruch.nenner + zweiterBruch.zaehler*nenner;
        nenner  = nenner*zweiterBruch.nenner;
        kuerzen();
    }
	  //Bruch kuerzen mittels ggt
  public int ggt (int zaehler, int nenner) {
     while (nenner != 0) {
    	 if (zaehler > nenner) {
    		 zaehler = zaehler - nenner;
    	 } else {
    		 nenner = nenner - zaehler;
    	 }
     }
     return zaehler;
    	 }
  

    
    //Bruch multiplizieren
    public Bruch MultiplikationBruch(Bruch zweiterBruch) throws Exception{
        if(zweiterBruch.nenner == 0){
            throw new Exception("Nenner darf nicht 0 sein");
        }
        
        int z = this.zaehler * zweiterBruch.zaehler ;
        int n = this.nenner * zweiterBruch.nenner;
        kuerzen();
        
        Bruch ausgabeBruch = new Bruch(z, n);
        
        ausgabeBruch.nenner = n;
        ausgabeBruch.zaehler = z;
        
        return ausgabeBruch;
        
    }
    
    private void kuerzen() {
    	int ggtteiler = ggt();
    	nenner = nenner / ggtteiler;
    	zaehler = zaehler / ggtteiler;
    }
    
    public int ggt() {
    	int a = zaehler;
    	int b = nenner;
    	int rest;
    	
    	while (b!=0) {
    		rest = a % b;
    		a = b;
    		b = rest;
    	}
    	return a;
    	}
		   //Ausgabe in "Bruch-Schreibweise"
    public String toString(){
        return zaehler + "/" + nenner ;
    }
}

Main.java

public class Main {
public static void main(String args[]) {
        
        try {
            Bruch b1 = new Bruch(1,2);
            Bruch b2 = new Bruch(1,4);
            System.out.println("Erster Bruch: " + b1.toString());
            System.out.println("Zweiter Bruch: " + b2.toString());
            //Ausgabe der Addition
            b1.AdditionBruch(b2);
            System.out.println("Addition: " + b1.toString());
            
            Bruch b3 = b2.MultiplikationBruch(b1);
            System.out.println("Multiplikationsergebnis: " + b3.toString());

        } catch (Exception e) {
        
            e.printStackTrace();
        }
    }
}

Kann noch jmd helfen?
Ich kapiere nicht, wie er bei der Multiplikation von 1/2 und 1/4 auf 3 / 16 kommt?
Er sollte ja eig kürzen! und das ergebnis müsste 1/8 sein...
mfg dbohnen

 

[SlaterB]

> wie er bei der Multiplikation von 1/2 und 1/4 auf 3 / 16 kommt?

wer sagt denn, dass die beiden Faktoren 1/2 und 1/4 sind? b1 veränderst du doch vorher..,
nicht so viel annehmen, mehr genau schauen, notfalls mit noch mehr System.out prüfen

 

[dbohnen]

ok... jetzt eine dumme frage, wie kann ich denn dafür sorgen, dass er auch bei der multiplikation von den ursprünglichen brüchen ausgeht ( b1 und b2)?

 

[SlaterB]

1.
Brüche neu anlegen/ kopieren/ zurückrechnen
oder
2.
add und mult usw. so bauen, dass sie die beteiligten Brüche nicht verändern sondern einen neuen dritten Bruch zurückgeben

 

[dbohnen]

haha... ich bin ja auch ein "dödel"...
ich kann ja einfach neue brüche "anlegen"...
danke dir, da stand ich aufm schlauch...