Eclipse Fehlermeldung "create constructor"

Neue Frage »

Auf diesen Beitrag antworten »
maxi2011816 Eclipse Fehlermeldung "create constructor"

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.
 
Auf diesen Beitrag antworten »
eulerscheZahl

Deine gui Klasse fehlt.
Wenn ich mir das anschauen soll, will ich das komplette Projekt als .zip. Entweder packst du den Projektordner oder in Eclipse mittels File/Export/Archive File
Auf diesen Beitrag antworten »
maxi20118161 Hier die Dateien

Vielen Dank für die schnelle Antwort! Wäre super, wenn du mal drüber guckst.
In der Zip. Sind glaube ich noch weiter Sachen, weil ich schnell machen musste. Einfach nur den einen Ordner Guido oder Brichrechnen benutzen.
Übrigens wird mir beim Feld "ZählerEcht" immer 0 angezeigt weshalb automatisch die dezimalzahl auch 0 ist.
Auf diesen Beitrag antworten »
eulerscheZahl

Bei mir lässt sich dein Code kompilieren (die Rechnen Klasse habe ich aus deinem ersten Beitrag, den Rest aus dem .zip).

if (Operator == "+") geht so nicht, du musst mit Operator.equals("+") prüfen.
 
Auf diesen Beitrag antworten »
maxi20118161

Danke, aber dennoch ist das Feld zaehlerEcht, also ungekürzt immer 0. Außerdem weiß ich nicht wie ich das Ergebnis kürzen soll. Immer wenn ich die eine Zeile in der Rechnen Klasse bei addieren aktivere ( also ohne //) gibt der mir einen Error aus.
Auf diesen Beitrag antworten »
eulerscheZahl

Wenn du da keine 0 haben willst, solltest du im Konstruktor nicht zaehlerEcht = 0; schreiben.

Bei dir würde ich noch mehr ändern. Du speicherst den Ganzzahlanteil des Bruchs und den Zähler getrennt, muss man bei Addition, Multiplikation, ... nur wieder mühsam zusammenrechnen.

Ein Bruch hat einen Zähler und Nenner, mehr braucht der nicht. Habe es mal schnell reingehackt.
code:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
public class Fraction {
	private int numerator;
	private int denominator;

	public Fraction(int numerator, int denominator) {
		this.numerator = numerator;
		this.denominator = denominator;
	}

	public Fraction add(Fraction frac) {
		Fraction result = new Fraction(
				this.numerator * frac.denominator + frac.numerator * this.denominator,
				this.denominator * frac.denominator);
		result.reduce();
		return result;
	}

	private static int gcd(int a, int b) {
		return a == 0 ? b : gcd(b % a, a);
	}

	public void reduce() {
		if (this.denominator < 0) {
			this.numerator *= -1;
			this.denominator *= -1;
		}
		int div = gcd(this.numerator, this.denominator);
		this.numerator /= div;
		this.denominator /= div;
	}

	public int getNumerator() {
		return numerator;
	}

	public int getDenominator() {
		return denominator;
	}

	public int getInteger() {
		return this.numerator / this.denominator;
	}

	public int getNumeratorWithoutInteger() {
		return numerator % denominator;
	}

	@Override
	public String toString() {
		if (numerator < 0)
			return "-" + new Fraction(-numerator, denominator).toString();
		if (numerator % denominator == 0)
			return String.valueOf(getInteger());
		if (numerator < denominator)
			return numerator + "/" + denominator;
		return getInteger() + " " + getNumeratorWithoutInteger() + "/" + denominator;
	}
}

code:
1:
2:
3:
Fraction f1 = new Fraction(1, 6);
Fraction f2 = new Fraction(11, 8);
System.out.println(f1.add(f2)); //1 13/24
Auf diesen Beitrag antworten »
maxi20118161 Kürzen?

Vielen Dank also einfach den Text von dir plus die Methoden für addieren subtrahieren multiplizieren und dividieren?
Und wie sieht dass aus mit kurzen?
Auf diesen Beitrag antworten »
eulerscheZahl

Ich habe dir die Addition, das Kürzen (Funktion reduce, wird am Ende von add aufgerufen) und die hübsche Ausgabe gemacht. -, * und / fehlen noch.
Auf diesen Beitrag antworten »
maxi20118161 Gui

Vielen Dank schonmal. Was muss ich denn nun in der Steuerung ändern außer halt das mit equals und was in gui?
 
Neue Frage »
Antworten »


Verwandte Themen

Die Beliebtesten »
Die Größten »
Die Neuesten »