|
|
Meine Frage:
Ich muss ein Programm für den Informatik Unterricht machen. Es soll Brüche zusammen rechnen können mit Hilfe der MVC Methode. Nun habe ich soweit alles fertig nur kriege ich immer eine Fehlermeldung: Ich solle doch einen constructor machen, welchen ich jedoch genau so wie er dort steht, habe.
Meine Ideen:
Dies ist meine Steuerung:
import java.awt.event.*;
/**
* Beschreiben Sie hier die Klasse Kontroller.
*
* @author (Ihr Name)
* @version (eine Versionsnummer oder ein Datum)
*/
public class Steuerung implements ActionListener {
// Der Controller kennt Model und View
private Gui gui = new Gui();
int[] zahlen = new int[5];
public Steuerung () {
gui.setbBerechneListener(this);
gui.setbLöschenListener(this);
}
public void actionPerformed(ActionEvent e) {
Rechnen bruch;
Rechnen bruchKürzen;
String Operator = gui.getOperator();
Rechnen bruch1 = new Rechnen(gui.getBruch()[0], gui.getBruch()[1], gui.getBruch()[2], gui.getBruch()[3]);
Rechnen bruch2 = new Rechnen(gui.getBruch1()[0], gui.getBruch1()[1], gui.getBruch1()[2], gui.getBruch1()[3]);
if (Operator == "+"){
bruch = bruch1.addieren(bruch2);
bruch = bruch.kürzen(bruch);
gui.setErgebnis(bruch.getzahl(), bruch.getzaehlerEcht(), bruch.getZaehler(), bruch.getNenner(), bruch.getDezimal());
}
if (Operator == "-"){
bruch = bruch1.subtrahieren(bruch2);
gui.setErgebnis(bruch.getzahl(), bruch.getzaehlerEcht(), bruch.getZaehler(), bruch.getNenner(), bruch.getDezimal());
}
if (Operator == "*"){
bruch = bruch1.multiplizieren(bruch2);
gui.setErgebnis(bruch.getzahl(), bruch.getzaehlerEcht(), bruch.getZaehler(), bruch.getNenner(), bruch.getDezimal());
}
if (Operator == "/"){
bruch = bruch1.dividieren(bruch2);
gui.setErgebnis(bruch.getzahl(), bruch.getzaehlerEcht(), bruch.getZaehler(), bruch.getNenner(), bruch.getDezimal());
}
/*if (gui.bKürzen.getModel().isPressed()==true){
System.exit(0);
}
*/
}
public static void main(String[] args) {
new Steuerung();
}
}
Und das die Klasse Rechnen:
/**
* Write a description of class Rechnen here.
*
* @author (your name)
* @version (a version number or a date)
*/
public class Rechnen
{
int zaehler1;
int zaehler2;
int zaehlerErgebnis;
int nenner1;
int nenner2;
int nennerErgebnis;
int erweiterteZahl;
int zaehlerErweitert;
int nennerErweitert;
int kuerzendeZahl;
int zaehlerGekuerzt;
int nennerGekuerzt;
int zaehlerTotalGekuerzt;
int nennerTotalGekuerzt;
double unechterBruchGanzeZahlKomma;
double unechterBruchGanzeZahl;
int unechterBruchZaehler;
int unechterBruchNenner;
double dezimalErgebnis;
int zahlErgebnis;
int zaehlerEcht;
protected int zahl, zaehler, nenner;
public Rechnen(int zahl1, int zaehlerEcht, int zaehler1, int nenner1) {
this.zahl = zahl1;
this.zaehler = zaehler1;
this.nenner = nenner1;
zaehlerEcht = 0;
}
public Rechnen addieren(Rechnen x){
if(x.nenner == this.nenner){
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = this.zaehler + x.zaehler;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
else{
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = x.zaehler * this.nenner + this.zaehler * x.nenner;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = x.nenner * this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
}
public Rechnen subtrahieren(Rechnen x){
if(x.nenner == this.nenner){
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = this.zaehler - x.zaehler;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
else{
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = this.zaehler * x.nenner - x.zaehler * this.nenner;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = x.nenner * this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
}
public Rechnen multiplizieren(Rechnen x){
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = x.zaehler * this.zaehler;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = x.nenner * this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
public Rechnen dividieren(Rechnen x){
if(this.zahl != 0){
this.zaehler = this.zahl * this.nenner + this.zaehler;
}
if(x.zahl != 0){
x.zaehler = x.zahl * x.nenner + x.zaehler;
}
zaehlerErgebnis = this.zaehler * x.nenner;
zaehlerEcht = zaehlerErgebnis;
nennerErgebnis = x.zaehler * this.nenner;
if((int) Math.floor(zaehlerErgebnis / nennerErgebnis) != 0 || (int) Math.floor(zaehlerErgebnis / nennerErgebnis) != -1){
zahlErgebnis = (int) Math.floor(zaehlerErgebnis / nennerErgebnis);
if (zaehlerErgebnis % nennerErgebnis == 0){
zaehlerErgebnis = 0;
nennerErgebnis = 0;
}
else{
zaehlerErgebnis = zaehlerErgebnis % nennerErgebnis;
}
}
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
public Double dezimal(){
return dezimalErgebnis = Math.round(zaehlerEcht / nennerErgebnis) / 1000;
}
public void erweiternMit(){
zaehlerErweitert = zaehlerErgebnis * erweiterteZahl;
nennerErweitert = nennerErgebnis * erweiterteZahl;
}
public void kuerzenMit(){
zaehlerGekuerzt = zaehlerErgebnis / kuerzendeZahl;
nennerGekuerzt = nennerErgebnis / kuerzendeZahl;
}
/*
* Berechnung des ggT zweier Zahlen
* nach dem Euklidischen Algorithmus
*/
private static int ggt(int zahl1, int zahl2) {
while (zahl2 != 0) {
if (zahl1 > zahl2) {
zahl1 = zahl1 - zahl2;
} else {
zahl2 = zahl2 - zahl1;
}
}
return zahl1;
}
/*
* Hauptprogramm:
*/
/**private int gcd(int zaehlerErgebnis, int nennerErgebnis){
int t;
while(nennerErgebnis != 0){
t = nennerErgebnis;
nennerErgebnis = zaehlerErgebnis % nennerErgebnis;
zaehlerErgebnis = t;
}
return zaehlerErgebnis;
}
public Rechnen kürzen()
{
zaehlerErgebnis = zaehlerErgebnis / gcd(zaehlerErgebnis, nennerErgebnis);
nennerErgebnis = nennerErgebnis / gcd(zaehlerErgebnis, nennerErgebnis);
return new Rechnen (zaehlerErgebnis, nennerErgebnis);
}
/* Methode zum Ermitteln des gr??ten gemeinsamen Teilers */
/**private int ggt(){
int u = zaehlerErgebnis;
int v = nennerErgebnis;
int hilf;
while(u>0){
hilf=u;
u=v%u;
v=hilf;
}
return v;
}
/* Methode zum K?rzen eines Bruches
public Rechnen kürzen()
{
zaehlerErgebnis = zaehlerErgebnis / ggt();
nennerErgebnis = nennerErgebnis / ggt();
return new Rechnen (zaehlerErgebnis, nennerErgebnis);
}
*/
public Rechnen totalKürzen(){
while ((zaehlerErgebnis % 100)==0 && (nennerErgebnis % 100)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 100;
nennerTotalGekuerzt = nennerErgebnis / 100;
}
while ((zaehlerErgebnis % 10)==0 && (nennerErgebnis % 10)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 10;
nennerTotalGekuerzt = nennerErgebnis / 10;
}
while ((zaehlerErgebnis % 9)==0 && (nennerErgebnis % 9)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 9;
nennerTotalGekuerzt = nennerErgebnis / 9;
}
while ((zaehlerErgebnis % 8)==0 && (nennerErgebnis % 8)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 8;
nennerTotalGekuerzt = nennerErgebnis / 8;
}
while ((zaehlerErgebnis % 7)==0 && (nennerErgebnis % 7)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 7;
nennerTotalGekuerzt = nennerErgebnis / 7;
}
while ((zaehlerErgebnis % 6)==0 && (nennerErgebnis % 6)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 6;
nennerTotalGekuerzt = nennerErgebnis / 6;
}
while ((zaehlerErgebnis % 5)==0 && (nennerErgebnis % 5)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 5;
nennerTotalGekuerzt = nennerErgebnis / 5;
}
while ((zaehlerErgebnis % 4)==0 && (nennerErgebnis % 4)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 4;
nennerTotalGekuerzt = nennerErgebnis / 4;
}
while ((zaehlerErgebnis % 3)==0 && (nennerErgebnis % 3)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 3;
nennerTotalGekuerzt = nennerErgebnis / 3;
}
while ((zaehlerErgebnis % 2)==0 && (nennerErgebnis % 2)==0){
zaehlerTotalGekuerzt = zaehlerErgebnis / 2;
nennerTotalGekuerzt = nennerErgebnis / 2;
}
return new Rechnen(zahlErgebnis, zaehlerEcht, zaehlerTotalGekuerzt, nennerTotalGekuerzt);
}
public void umformenInUnechtenBruch(){
if (zaehlerErgebnis % nennerErgebnis == 0){
unechterBruchGanzeZahl = zaehlerErgebnis / nennerErgebnis;
unechterBruchZaehler = 0;
unechterBruchNenner = 0;
}
else{
if ((zaehlerErgebnis / nennerErgebnis) >= 1){
unechterBruchGanzeZahlKomma = zaehlerErgebnis / nennerErgebnis;
unechterBruchGanzeZahl = Math.floor(unechterBruchGanzeZahlKomma);
}
}
}
public void umformenInDezimalzahl(){
dezimalErgebnis = zaehlerErgebnis / nennerErgebnis;
}
public int getzahl(){
return zahl;
}
public int getzaehlerEcht(){
return zaehlerEcht;
}
public int getZaehler(){
return zaehler;
}
public int getNenner(){
return nenner;
}
public double getDezimal(){
return dezimalErgebnis;
}
public Rechnen kürzen(Rechnen x) {
// berechne ggT mit der Funktion "ggt()"
zaehlerEcht = zaehlerErgebnis / ggt(zaehlerErgebnis, nennerErgebnis);
nennerErgebnis = nennerErgebnis / ggt(zaehlerErgebnis, nennerErgebnis);
return new Rechnen (zahlErgebnis, zaehlerEcht, zaehlerErgebnis, nennerErgebnis);
}
}
Wie gesagt er sagt ich solle einen Konstruktor der Form Rechnen (int,int,int,int) machen welcher jedoch ganz oben schon besteht. Zudem sagt er mir, dass meine Methode kürzen falsch sei.
|
|
