# Rechnen mit zwei Brüchen. Komme nicht weiter



## egal123 (29. Dez 2013)

Hey Leute, ich studiere derzeit Wirtschaftsinformatik und knobel über einer Hausaufgabe.
Ich bin noch nicht sehr geübt in Java und weiß echt nicht weiter ... 
Dazu kommt, dass unsere Professorin nicht gerade Profi im Aufgabenstellungen-Formulieren ist und gerne mal Themen mit in die Aufgabe einbezieht, die wir so noch gar nicht in den Vorlesungen hatten. 

Ein paar Methoden, die Namen der Klassen, das komplette Interface usw. die wir unbedingt mit verwenden sollen, wurden von der Professorin vorgegeben, aber halt alles sehr lückenhaft und das bringt mich eigentlich nochmehr durcheinander....

Wir sollen als Aufgabe ein kleines, ich nenne es mal Spiel, für das Rechnen mit zwei Brüchen erstellen.
Dabei sollen wir mit verschiedenen Klassen arbeiten und einem Interface (Ratio-Class,Engine-Class, Start-Class und das IRatio-Interface). Der Benutzer soll nacheinander zwei rationale Zahlen als String in der Form z/n eingeben und danach noch einen Operator mit denen dann gerechnet werden soll. Alle rationale Zahlen sollen in einem! Array abgespeichert werden und der Benutzer soll so oft spielen/rechnen können wie er möchte. (Die Schleife hab ich jetzt noch nicht mit eingebaut)
Am Ende des Spiels wird dem Benutzer eine Zusammenfassung der aller Rechnungen ausgeben.
Also die beiden rationalen Zahlen, der Operator und das jeweilige Ergebnis dazu. 

*Mein größtes Problem derzeit ist, dass ich nicht verstehe, wieso das Programm anscheind immer auf den Default-Konstruktur greift und gar nicht die eingegeben Zahlen benutzt. 

... aber ich vermute, dass ich da diverse falsche Ansätze im Programm habe, ich weiß aber nicht welche und hoffe ihr könnt mir ein wenig weiter helfen ... paar kleine Denkansätze reichen ja schon, nur damit das mal endlich etwas in die richtige Richtung läuft ... *

Ach und noch eine kleine dumme Frage, wofür soll dieses vorgegebene Interface, welches wir da mit einbauen sollen, eigentlich gut sein? Ich versteh nicht, wieso wir eins bei dieser Aufgabe verwenden sollen., genauso wenig verstehe ich derzeit den Sinn der Vergleichsmethode in der Klasse Ratio. 
Wozu soll es sinnvoll sein, ob die Zähler und Nenner beider rationaler Zahlen gleich sind?
Steh leider vollkommen auf dem Schlauch ... 


```
package uebRatio;

public class Ratio implements IRatio {

	
	private int zaehler;
	
	private int nenner;
	

	// Zugriffsmethoden Setter/Getter:
	
	int getNenner(){  
	
		return nenner;
	}
	
	void setNenner(int nenner){	
		

			this.nenner=nenner;

	}
	
	
	int getZaehler(){	
		
		return zaehler;
	}
	
	int setZaehler(int zaehler){	
		
		this.zaehler=zaehler;
		
		return zaehler;
	}
	
	
	@Override 
	public String toString() {  // wandelt ein Objekt der Klasse Ratio in einen String der Form "z/n"
		
		
		String str=this.zaehler + "/" + this.nenner;
		
		return str;
		
	}
	
	
	public Ratio(){   //Default-Konstruktor
		
		zaehler=0;
		nenner=1;
	}
	
	public Ratio(int zaehler, int nenner){   //überladener Konstruktor mit Paramentern 
		
		this.zaehler=zaehler;
		this.nenner=nenner;
	}

	

	
	//mathematische Methoden:
	
	 public Ratio addiere(Ratio zahl2) {   // Addition von zwei rationalen Zahlen
		 
		 Ratio ergebnis = new Ratio();
		
		 ergebnis.zaehler = zaehler * zahl2.nenner + zahl2.zaehler * nenner;
		 ergebnis.nenner  = nenner * zahl2.nenner;
		 
		 
		 
		 return ergebnis.kuerze(); // Rückgabewert; Ergebnis der Addition als gekürzte rationale Zahl
		 
		 
	 }
	 
	public Ratio subtrahiere(Ratio zahl2) {   // Subtraktion von zwei rationalen Zahlen
		
		Ratio ergebnis = new Ratio();
		
		ergebnis.zaehler = zaehler * zahl2.nenner - zahl2.zaehler * nenner;
		ergebnis.nenner  = nenner * zahl2.nenner;
		

		
		return ergebnis.kuerze();
	
	}

	
	public Ratio multipliziere(Ratio zahl2) {  // Multiplikation von zwei rationalen Zahlen
		
		Ratio ergebnis = new Ratio();
		
		ergebnis.zaehler = zaehler * zahl2.zaehler;
		ergebnis.nenner  = nenner * zahl2.nenner;
		
		
		
		return ergebnis.kuerze();
	
	}  
	

	public Ratio dividiere(Ratio zahl2) throws ArithmeticException{ 
		
				Ratio ergebnis = new Ratio();
			try
			{		
				
				int divisionDurchNullTest=zahl2.nenner/zahl2.zaehler;
				
				ergebnis.zaehler = zaehler * zahl2.nenner;
				ergebnis.nenner  = nenner * zahl2.zaehler;
	
			}
			catch(ArithmeticException ex){
				
				System.out.println("Division durch 0 nicht möglich");
			}
		
			
			
			return ergebnis.kuerze();
			
			}
	
	public Ratio kuerze() { // Euklidischer Algorithmus
		
		int i,
        n= Math.abs(nenner), 
        z= Math.abs(zaehler);

        while (z > 0){
           if( z < n ){
               i= n; 
               n= z; 
               z= i;
           }
           z= z - n;
       }
       nenner= nenner / n;
       zaehler= zaehler / n;
       return this;
		
	} 
	

		
	//Vergleichsmethode:
	
	public boolean equals(Ratio zahl2)
	{
        if(this.nenner == zahl2.nenner && this.zaehler == zahl2.zaehler){
          
        	return true;
            
        }
        else
        {
            return false;
            
        }
        }
	
}
```


```
package uebRatio;

import java.util.ArrayList;
import java.util.Scanner;

public class Engine extends Ratio implements IRatio{
	
	
	
	Scanner scan = new Scanner(System.in);
	
	public ArrayList<Ratio> rArray = new ArrayList<Ratio>();
	public ArrayList<String> opArray = new ArrayList<String>();
	

	private String str; 
	private String op;
	

	private String ausgabeString;
	
	public String eingabeRatio(){ // Eingabe der Ratio Zahl 
	
		str=scan.next();
	
		return str;
	
	}
	
	public String eingabeOperator(){  // Eingabe des Operators
		
		op=scan.next();
		
		return op;
	}
	
	
	public void saveRatioZahl(Ratio r){  // Ratio Zahl wird in ArrayList abgespeichert 
		
		try{
			
		rArray.add(r);
		
		}
		catch(ArrayIndexOutOfBoundsException ex){
			
			System.out.println("Achtung: falsche Eingabe " +"Bitte neu in der Form z/n eingeben (Bsp.: 2/3)");
			eingabeRatio();
		}
	}
		

	public void saveOperator(String op){  // Operator wird in ArrayList als String abgespeichert
		
		if(op.equals("/") ||op.equals("*") || op.equals("+") || op.equals("-"))
		{
			opArray.add(op); 
		}
		
		else
		{
			System.out.println("falsche Eingabe - bitte Operator neu eingeben ");
			eingabeOperator();
		}
			
	}
	
	
	public void berechnen(Ratio r){  //Berechnungen
		
	
		if(op.equals("+")){
		
			addiere(r);				
		}
		if(op.equals("-")){
			
			subtrahiere(r);
		}
		if(op.equals("*")){
			
			multipliziere(r);
		}
		if(op.equals("/")){
			dividiere(r);
		}
	
			saveRatioZahl(r);
		
			
	}

	public String restore(int index){ 
		
		ausgabeString=rArray.get(index).toString();
			
		return ausgabeString;
		
	}


	public void ausgabe(String ausgabeString){  
        // nicht vollständig, nur zum testen der Ausgabe erstmal
		
		System.out.println(restore(0)+ " " + opArray.get(0) + "" + restore(1) + " " + "= " + restore(2));
		
	
	}
	
	

	 private Ratio string2ratio(String str) // String (Eingabe) wird in Ratio Zahl umgewandelt 
	 {  
		
		 	String[] split = new String[2];
		 
		 	split = str.split("/");
		 	
		 	int zaehler=Integer.parseInt(split[0]);
		 	int nenner=Integer.parseInt(split[1]);
		 	
		 	Ratio r= new Ratio(zaehler, nenner);
			 
			r.setZaehler(zaehler); 
			r.setNenner(nenner);
		 	
			return r;
			
		}
		 
	 
	public void losgehts(){
		
		Ratio r = new Ratio();
		
		
		System.out.println("Bitte rationale Zahl eingeben in der Form z/n");
		eingabeRatio();
		
		string2ratio(str);
		saveRatioZahl(r);
		
		System.out.println("Bitte rationale Zahl eingeben in der Form z/n");
		eingabeRatio();
		string2ratio(str);
		saveRatioZahl(r);
		
		System.out.println("Bitte Operator eingeben [+ - * / %]");
		eingabeOperator();
		saveOperator(op);
		
		berechnen(r);
		saveRatioZahl(r);
		System.out.println(r);
		
		ausgabe(ausgabeString);
	}
	}
```


```
package uebRatio;

public interface IRatio {
	
	public Ratio addiere(Ratio zahl2);

	public Ratio subtrahiere(Ratio zahl2);

	public Ratio multipliziere(Ratio zahl2);

	public Ratio dividiere(Ratio zahl2) throws ArithmeticException;
	
	public Ratio kuerze(); // Euklidischer Algorithmus 

}// end of interface
```


----------



## Deros (30. Dez 2013)

du rufst auch nur den default constructer auf, wie sollen die Zahlen denn überhaupt in das Ratio Objekt kommen? Du nutzt weder die setter noch den "überladenen" Constructor. Anstelle dessen hast du in der Klasse Engine zwei Arrays deren Sinn mich mir überhaupt nicht erschliesst, was erhoffst du dir dadurch?


----------

