# klasse für ein Rechteck schreiben



## Exceptionist (12. Dez 2007)

huhu, ich bastel grad an einem progrämmchen, das geometrische dinge berechnen soll...mit nem quadrat klappt das schon ganz gut, nur beim Rechteck hab ich probleme.
bei einem quadrat reicht ja ein einzelner wert, doch bei nem rechteck und allen anderen geometrischen flächen oder formen brauch ich ja mindestens zwei werte.
wie muss ich da vorgehen??

ich poste hier mal meine quadratklasse und hoffe daß mir jemand tips geben kann, wie ich die rechteck-klasse schreiben muss/sollte.


```
package zweidimensional;
import java.math.*;

public class Quadrat {
private double seitenlaenge;
private double flaeche;
private double umfang;
private double diagonale;



public double getSeitenlaenge() {
    return seitenlaenge;
}


public void setSeitenlaenge(double seitenlaenge) {
    this.seitenlaenge = seitenlaenge;
    this.flaeche = seitenlaenge*seitenlaenge;
    this.umfang = seitenlaenge*4;
    this.diagonale = seitenlaenge*Math.sqrt(2);
}


public double getFlaeche() {
    return flaeche;
}


public void setFlaeche(double flaeche) {
    this.flaeche = flaeche;
    this.seitenlaenge = Math.sqrt(flaeche);
    this.umfang = seitenlaenge*4;
    this.diagonale = seitenlaenge*Math.sqrt(2);
}


public double getUmfang() {
    return umfang;
}


public void setUmfang(double umfang) {
    this.umfang = umfang;
    this.seitenlaenge = umfang/4;
    this.diagonale = seitenlaenge*Math.sqrt(2);
    this.flaeche = seitenlaenge*seitenlaenge;
}


public double getDiagonale() {
    return diagonale;
}


public void setDiagonale(double diagonale) {
    this.diagonale = diagonale;
    this.seitenlaenge = diagonale/Math.sqrt(2);
    this.flaeche = seitenlaenge*seitenlaenge;
    this.umfang = seitenlaenge*4;
}



 /*
public static void main(String[] args) {
    Quadrat quad = new Quadrat();
    quad.setSeitenlaenge(6);
    System.out.println(quad.getSeitenlaenge());
    System.out.println(quad.getFlaeche());
    System.out.println(quad.getUmfang());
    System.out.println(quad.getDiagonale());
}
*/


}
```

hatte meine rechteck-klasse auch so aufgebaut, aber jenachdem wie ich diverse variablen  in der main gefüllt habe, kamen unterschiedliche werte (unter anderem infinit) dabei raus!

hier mal mein bisheriger code fürs rechteck:


```
package zweidimensional;
import java.math.*;


public class Rechteck {
    private double seitenlaenge_a = 0;
    private double seitenlaenge_b = 0;
    private double flaeche = 0;
    private double umfang = 0;
    private double diagonale = 0;
    
    
    
    public double getSeitenlaenge_a() {
        return seitenlaenge_a;
    }
    public void setSeitenlaenge_a(double seitenlaenge_a) {
        this.seitenlaenge_a = seitenlaenge_a;
        this.umfang = 2*(this.seitenlaenge_a+seitenlaenge_b);
        this.flaeche = this.seitenlaenge_a*seitenlaenge_b;
        this.diagonale = Math.sqrt((this.seitenlaenge_a*this.seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
        
    }
    
    public double getSeitenlaenge_b() {
        return seitenlaenge_b;
        
    }
    public void setSeitenlaenge_b(double seitenlaenge_b) {
        this.seitenlaenge_b = seitenlaenge_b;
        this.umfang = 2*(seitenlaenge_a+seitenlaenge_b);
        this.flaeche = seitenlaenge_a*seitenlaenge_b;
        this.diagonale = Math.sqrt((seitenlaenge_a*seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
        
    }
    
    public double getFlaeche() {
        return flaeche;
    }
    public void setFlaeche(double flaeche) {
        this.flaeche = flaeche;
        seitenlaenge_a = flaeche/seitenlaenge_b;
        seitenlaenge_b = flaeche/seitenlaenge_a;
        umfang = 2*(seitenlaenge_a+seitenlaenge_b);
        diagonale = Math.sqrt((seitenlaenge_a*seitenlaenge_a)+(seitenlaenge_b*seitenlaenge_b));
           
    }
    
    public double getUmfang() {
        return umfang;
    }
    public void setUmfang(double umfang) {
        this.umfang = umfang;
        this.seitenlaenge_a = (umfang/2) - seitenlaenge_b;
        this.seitenlaenge_b = (umfang/2) - seitenlaenge_a;
      
    }
    
    public double getDiagonale() {
        return diagonale;
    }
    public void setDiagonale(double diagonale) {
        this.diagonale = diagonale;
    }
    
    
    
    public static void main(String[] args) {
       Rechteck rect = new Rechteck();
       rect.setSeitenlaenge_b(10);
       rect.setSeitenlaenge_a(5);
       
       rect.setFlaeche(25);
       
       
       System.out.println("a= "+ rect.getSeitenlaenge_a());
       System.out.println("b= "+ rect.getSeitenlaenge_b());
       System.out.println("A= "+ rect.getFlaeche());
       System.out.println("d= "+ rect.getDiagonale());
       System.out.println("U= "+ rect.getUmfang());
    }
}
```

oder muss ich etwa die setter und getter-methoden so machen, daß wirklich nur der entsprechende wert gesetzt wird?
hab an andere weitere methoden gedacht, die dann die berechnungen durchführen, jedoch hab ich das problem, daß ich nicht weiß wie das dann nachher mit der wert-übergabe laufen soll(eben wegen der zwei variablen)...

bisher sieht das progrämmchen so aus: bitte klicken


----------



## sliwalker (12. Dez 2007)

Hoi,

da jedes Quadrat mathematisch auch ein Rechteck ist, kannst Du einfach sagen "class Rechteck extends Quadrat".

Unschön ist an deiner Klasse, dass Du Varaiblen für die Fläche, Diagonale und Umfang hast. Das sind Werte die sich berechnen lassen und müssen nicht gespeichert werden.
Die können raus und die methoden getFlaeche usw. berechnen und geben sofort zurück.

Wenn Du Rechteck von Quadrat erben lässt, musst Du nur noch diese methoden "überschreiben" dass heißt mit neuem Code befüllen. In eclipse werden dir Methoden, die Du überschreibst mit einem grünen Pfeil markiert.

Überschreiben tut man, indem man die Methode einfach nochmal neu reinschreibt. Und zwar genauso deklariert wie in der Superklasse. Denn Deine vererbte Klasse ist ja leer, wenn Du sie erstellst.
Die variablen brauchst Du nicht neu deklarieren und greifst mit super. drauf zu.

greetz
SLi


----------



## mikachu (12. Dez 2007)

sliwalker hat gesagt.:
			
		

> ...da jedes Quadrat mathematisch auch ein Rechteck ist, kannst Du einfach sagen "class Rechteck extends Quadrat"...



class Quadrat extends Rechteck

weil: ein quadrat *ist ein* rechteck mit gleicher seitenlänge


----------



## Niki (12. Dez 2007)

Ich würd Quadrat eher von Rechteck ableiten und die Methoden überschreiben:
Rechteck:

```
public class Rechteck{
  private int a = 0;
  private int b = 0;

  public void setA(int a){
    this.a = a;
  }
  // weitere setter und getter...

  public int berechneFlaeche(){
    return a * b;
  }
}
```

Quadrat:

```
public class Quadrat extends Rechteck{  

  public void setA(int a){
    super.setA(a);
    super.setB(a);  
  }

  //wichtig ist beide Methoden zu überschreiben, da du bei einem Quadrat ja nur eine Seitenangabe benötigst
  public void setB(int b){
     setA(b);
  }


}
```


----------



## Exceptionist (12. Dez 2007)

ja aber die brechnung an sich ist doch eine andere, weil ich doch beim rechteck 2 variablen brauche, die ich beim quadrat net brauche...


----------



## sliwalker (12. Dez 2007)

...*räusper*...

ich bestehe weiterhin auf *auch*, da ein Quadrat auch ein Parallelogramm ist.


----------



## sliwalker (12. Dez 2007)

Naja...


...das ist Ansichtssache.
ich würde ein Quadrat nicht nur mit einer Seite erstellen.
Denn streng genommen hat es zwei Seiten, die eben nur gleich lang sind. Wer da nur eine deklariert und die doppelt rechnet...naja..ich würde es so nicht machen.

Und objektorientiert gesehen (RealLife im Programm abbilden) gehört Rechteck von Quadrat abgeleitet und nicht andersrum. Sonst wird es auch verwirrend...nimmt man mal ein komplexeres Beispiel....

greetz
SLi


----------



## Exceptionist (12. Dez 2007)

Niki hat gesagt.:
			
		

> Ich würd Quadrat eher von Rechteck ableiten und die Methoden überschreiben:
> Rechteck:
> 
> ```
> ...



mein problem an dieser stelle ist ja daß ich net weiß welche variablen gegeben sein werden...
wenn ihr oben auf den link klickt könnt ihr ja mein kleines gui angucken...
was wäre zB wenn jemand die fläche und eine seite kennt, aber net die zweite seite... oder eine seite und die diagonale
am anfang dachte ich echt das wär ne gute übung um wieder etwas in den ganzen javakram reinzukommen... mittlerweile hab ich das gefühl ich hab mir zu viel aufgelastet^^


----------



## Niki (12. Dez 2007)

mikachu hat gesagt.:
			
		

> weil: ein quadrat *ist ein* rechteck mit gleicher seitenlänge



Dem kann ich nur zustimmen!

Bei meinem Beispiel oben hat ein Quadrat auch zwei Seiten, die halt immer den selben Wert haben müssen. Ich finde diese Lösung doch schick!


----------



## Exceptionist (12. Dez 2007)

und wie würdest du bei deiner lösung vorgehen, wenn ich dir nur eine seite und die fläche geben würde?? also beim rechteck, net beim quadrat


----------



## sliwalker (12. Dez 2007)

Dann musst Du eien methode schreiben die ungefähr so heißt:

setSeitenByFlaeche()
setSeitenByDiagonale()

(tolles denglisch  )
EDIT: prüf beim setzen vorher ab ob eine Seite schon gesetzt ist oder ob es ein initialwert gibt. Das kannst Du gut machen, indem Du nicht int sonder Integer verwendest und das auf null setzt beim erstellen des Objekts.


Bloß nicht aufgeben. genau solche Situationen bringen Dir am meisten. Wer sich lange mit einem problem beschäftigt und es dann auch löst wird es so schnell nicht wieder vergessen...

greetz
SLi


----------



## Exceptionist (12. Dez 2007)

ok dann angenommen ich schreib mir für solche fälle die methoden, wie kommt dann das auslesen aussm gui?
dann müsste ich ja sozusagen über die namen der inputfelder auslesen WAS nen inhalt hat und dann erst die methode aufrufen, die des ausrechnet?
denn mein prob setzt sich ja eigentlich aus dem bilden der klasse und dem einbinden ins gui zusammen..
die grundlagen dafür kann ich ja und bekomm des auch hin, aber irgendwie hat  mich niemals jemand programm- und programmier-struktur glehrt.

hat sich eigentlich schonmal jemand die jar-file angesehen?


----------



## Niki (12. Dez 2007)

in Klasse Rechteck:

```
public void setFlaeche(int flaeche) {
  if(a != 0){
    b = flaeche / a;
  } else if(b != 0){
    a = flaeche / b;
  } else{
   throw IllegalStateException("Es muss eine Seite angegeben sein");
  }  
}
```

in Klasse Quadrat:

```
public void setFlaeche(int flaeche) {
  setA(Math.sqrt(flaeche));
}
```


----------



## sliwalker (12. Dez 2007)

Exceptionist hat gesagt.:
			
		

> ok dann angenommen ich schreib mir für solche fälle die methoden, wie kommt dann das auslesen aussm gui?
> dann müsste ich ja sozusagen über die namen der inputfelder auslesen WAS nen inhalt hat und dann erst die methode aufrufen, die des ausrechnet?



Ja, also es ist schon wichtig, dass die Werte die eingebenen werden auch im Programm als das behandelt werden, wie es der User meinte. Da wirst Du nicht drumherumkommen...


----------



## Exceptionist (12. Dez 2007)

Ok ich schreib dann jetzt mal alles um und warte auf die nächste exception^^... meld mich dann wieder...
danke erstmal für eure anregungen!
(und da war ich so froh, daß mein quadrat funktioniert hat*schüff*)


----------



## sliwalker (12. Dez 2007)

:lol: 

Ja, dann viel Erfolg...


----------



## Marco13 (12. Dez 2007)

Hatte das in einer PN shcon geschrieben: Ein Rechteck ist beschrieben durch
Fläche + SeiteA
Fläche + SeiteB
SeiteA + SeiteB
Fläche + Diagonale
SeiteA + Diagonale
SeiteB + Diagonale

Wenn man für jede dieser Möglichkeiten eine eigene Methode anbieten will, ist das schon ein ziemlicher Overkill. Aber spätestens beim Dreieck wird's dann richtig eklig: Ein Dreieck hat z.B. 
Winkel wA, wB, wC
Seiten sA, sB, sC
und kann beschrieben werden durch...
wA, sC, wB
wB, sA, wC
wC, sB, wA
sA, sB, sC
sA, sB, wA
sB, sC, wB
...
(vmtl. noch etliche mehr)

Dafür jeweils eine Methoden anzubieten ist wohl nicht sinnvoll. Vorauszusetzen, dass die Werte in einer bestimmten Reihenfolge gegeben werden würde die Klasse auch "schwer" benutzbar machen. Die einzige (für den Benutzer!() komfortable) Möglichkeit, die ich sehe, ist so eine Abfrage, wie Niki sie angedeutet hat. Allerdings ohne die Exception, sondern nach Möglichkeit so, dass die Fläche gespeichert wird, und "so bald wir möglich" die Ergebnisse berechnet werden. Es könnte dafür z.B. eine spezielle Inputdaten-Klasse geben, die mit eingegebenen Werten gefüllt wird, und irgendwo "true" liefert, wenn man alle anderen Werte aus den Eingaben berechnen kann oder so... (Zumindest stimme ich AUCH damit überein, dass das eigentliche Rechteck keine Redundanten Daten enthalten sollte - also z.B. nur SeiteA und SeiteB, aber dann nicht zusätzlich noch die Fläche). 

Hmja. Das ganze ist wohl nicht so trivial, wie es im ersten Moment scheint....


----------



## Guest (12. Dez 2007)

sliwalker hat gesagt.:
			
		

> Hoi,
> 
> da jedes Quadrat mathematisch auch ein Rechteck ist, kannst Du einfach sagen "class Rechteck extends Quadrat".



Mathematisch ja, OO-technisch nein.


----------



## Exceptionist (12. Dez 2007)

ja wer erbt denn jetzt von wem?? ich hätt quadrat extends rechteck genommen jetzt...
und die inputdaten-klasse würd ich jetzt in meine validator-klasse (der den inhalt der textfelder checkt) einbauen.
nur hab ich noch keine idee wie ich das handhaben werde/müsste.
hab halt bisher noch nie sowas gemacht.
kennt jemand von euch nen link oder sowas (evtl ne buchempfehlung)
wo man was über programmier-abläufe erfährt?
bringt ja nix wenn man den syntax von ner OO-sprache wie java versteht, aber das ganze wissen nich anwenden kann


----------



## sliwalker (12. Dez 2007)

Anonymous hat gesagt.:
			
		

> sliwalker hat gesagt.:
> 
> 
> 
> ...



Dann mach Dir wenigstens die Mühe das zu erläutern.
Das man nicht einfach extends schreibt und alles läuft ist ja wohl klar...
..bei welcher Vererbung ist das schon so?


----------



## Exceptionist (12. Dez 2007)

Niki hat gesagt.:
			
		

> Ich würd Quadrat eher von Rechteck ableiten und die Methoden überschreiben:
> Rechteck:
> 
> ```
> ...




hab grad akut ein problem mit dem überschrieben der methode setSeitenlaenge_B() [im zitat is des super.setB(a)], denn das haut bei mir so net hin, da bekomm ich infinity-werte...

hier mal meine codes:
RECHTECK:

```
package zweidimensional;
import java.math.*;


public class Rechteck {
    protected double seitenlaenge_A;
    protected double seitenlaenge_B;
    protected double flaeche;
    protected double umfang;
    protected double diagonale;



    
    
    public double getSeitenlaenge_A() {
        return seitenlaenge_A;
    }

    public void setSeitenlaenge_A(double seitenlaenge_A) {
        this.seitenlaenge_A = seitenlaenge_A;
    }

    public double getSeitenlaenge_B() {
        return seitenlaenge_B;
    }

    public void setSeitenlaenge_B(double seitenlaenge_B) {
        this.seitenlaenge_B = seitenlaenge_B;
    }

    public double getFlaeche() {
        return flaeche;
    }

    public void setFlaeche(double flaeche) {
        this.flaeche = flaeche;
    }

    public double getUmfang() {
        return umfang;
    }

    public void setUmfang(double umfang) {
        this.umfang = umfang;
    }

    public double getDiagonale() {
        return diagonale;
    }

    public void setDiagonale(double diagonale) {
        this.diagonale = diagonale;
    }

    public void calcArea(double a, double b){
        a = this.seitenlaenge_A;
        b = this.seitenlaenge_B;
        flaeche = a*b;
        setFlaeche(flaeche);
    }
    
    public void calcUmfang(double a, double b){
        a = this.seitenlaenge_A;
        b = this.seitenlaenge_B;
        umfang = 2*(a*b);
        setUmfang(umfang);
    }
    
    public void calcDiagonale(double a, double b){
        a = this.seitenlaenge_A;
        b = this.seitenlaenge_B;
        diagonale = Math.sqrt(((getSeitenlaenge_A()*getSeitenlaenge_A())+(getSeitenlaenge_B()*getSeitenlaenge_B())));
        setDiagonale(diagonale);
    }
    
    public void calcSeiteAvomUmfang(double b, double u){
        b = this.seitenlaenge_B;
        u = this.umfang;
        setSeitenlaenge_A((u/2)-b);
    }
    
    public void calcSeiteBvomUmfang(double a, double u){
        a = this.seitenlaenge_B;
        u = this.umfang;
        setSeitenlaenge_B((u/2)-a);
    }

    public void calcSeiteAvonFlaeche(double b, double A){
        b = this.seitenlaenge_B;
        A = this.flaeche;
        setSeitenlaenge_A(A/b);
    }
    
    public void calcSeiteBvonFlaeche(double a, double A){
        a = this.seitenlaenge_B;
        A = this.flaeche;
        setSeitenlaenge_B(A/a);
    }
    
    public static void main(String[] args) {
       Rechteck rect = new Rechteck();
       rect.setSeitenlaenge_B(10);
      
       rect.setFlaeche(25);
       
       rect.calcSeiteAvonFlaeche(rect.getSeitenlaenge_B(), rect.getFlaeche());
       
       rect.calcDiagonale(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
       
       rect.calcUmfang(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
       
      //rect.calcArea(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
      //rect.setSeitenlaenge_A(10);
      
       System.out.println("a= "+ rect.getSeitenlaenge_A());
       System.out.println("b= "+ rect.getSeitenlaenge_B());
       System.out.println("A= "+ rect.getFlaeche());
       System.out.println("d= "+ rect.getDiagonale());
       System.out.println("U= "+ rect.getUmfang());
    }
}
```

und hier dat quadrat (mit main)

```
package zweidimensional;
import java.math.*;

public class Quadrat extends Rechteck{
   

  
    public double getSeitenlaenge_A() {
        return seitenlaenge_A;
    }

    public void setSeitenlaenge_A(double seitenlaenge_A) {
        this.seitenlaenge_A = seitenlaenge_A;
    }

    public double getSeitenlaenge_B() {
        return seitenlaenge_B;
    }

   public void setSeitenlaenge_B(double seitenlaenge_B) {
       setSeitenlaenge_A(seitenlaenge_B);
   
          
   }

    
    public static void main(String[] args) {
        Rechteck rect = new Quadrat();
        rect.setSeitenlaenge_B(10);
       
        rect.setFlaeche(25);
        
        rect.calcSeiteAvonFlaeche(rect.getSeitenlaenge_B(), rect.getFlaeche());
        
        rect.calcDiagonale(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
        
        rect.calcUmfang(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
        
       //rect.calcArea(rect.getSeitenlaenge_A(), rect.getSeitenlaenge_B());
       //rect.setSeitenlaenge_A(10);
       
        System.out.println("a= "+ rect.getSeitenlaenge_A());
        System.out.println("b= "+ rect.getSeitenlaenge_B());
        System.out.println("A= "+ rect.getFlaeche());
        System.out.println("d= "+ rect.getDiagonale());
        System.out.println("U= "+ rect.getUmfang());
     }
}
```

dat ergebnis ist dann folgendes:

a= Infinity
b= 0.0
A= 25.0
d= Infinity
U= NaN


jemand evtl ne idee, die abhilfe schafft?
das mit der input-class hab ich noch nicht so ganz verstanden und umsetzen können..


----------



## tfa (12. Dez 2007)

Ja. Leite Quadrat nicht von Rechteck ab (siehe Nachbarthread). 
In Deiner Lösung jetzt ist die eine Seitenlänge undefiniert. Deswegen knallts.


----------



## Niki (12. Dez 2007)

Du solltest auch deine Felder nicht protected sonder private machen und nur über die Methoden darauf zugreifen. Wenn du im Quadrat eine Seitenlänge setzt, musst du die andere Seitenlänge auf den selben Wert setzen. Das hast du vergessen, deswegen ist eine Seite 0.0 und daher kommen diese Ergebnisse zu stande.


----------



## function (12. Dez 2007)

Ok ich hab jetzt auch mal die ganzen posts durch gelesen und ich verstehe nicht warum überhaupt eine Quadratklasse erstellt werden soll und damit is auch eine vererbung irrelevant:
Ich denke wir sind uns einig das jedes Quadrat ein Rechteck ist, mit der besonderheit das die beiden seiten gleichlang sind. Daraus folgt das alle Formeln ("Berechnungen") die für ein Rechteckgelten auch immer für ein Quadrat richtig sind. Und dabei ist es nun egal wie das Rechteck angegeben wird, eine Seite+Diagonale, eine Seite+Flächeninhalt... Für keine Berechnung ist es Explizit wichtig zu wissen ob es sich um ein quadrat oder ein Rechteck handelt. 
Ausser es ist nur ein einziger Wert gegeben, da ist die Berechnung nur möglich wenn es sich um ein Quadrat handelt


----------



## function (12. Dez 2007)

Was deinen Code angeht, du hast meines erachtens nach die setSeitelaenge_B falsch über schrieben es müßte in der Klasse quadrat:

```
public void setSeitenlaenge_B(double seitenlaenge_A) {
```

weiterhin würde ich die berechnungen Parameterlos aufrufen, sondern sie direkt auf deine "privaten" variablen zugreifen lassen. Weil du zuvor ja die Werte über die setter belegst solltest du darauf verzichten die berechnung mit werten auf zurufen.


----------



## Marco13 (12. Dez 2007)

Hm. Nochmal unabhängig von der (philosphischen) Frage nach der Vererbung (die hier eh keine Rolle spielen sollte, und in einem anderen Thread diskutiert wird) zum konkreten Problem: Wenn du für jede beliebige Kombination von Eingabewerten eine public-Methode anbieten willst, wird das (für den Benutzer der Klasse!) aufwändig. Wenn die Klasse ihren Zustand selbst regelt, wird das (für den, der die Klasse schreibt) aufwändig (aber für den, der sie verwendet, SEHR einfach). (Für dich, der sowohl die Klasse selbst als auch den Aufrufer schreibt, wird es also in jedem Fall aufwändig... der Package-Name 'zweidimensional' läßt große Ambitionen für die Zukunft vermuten :wink: ).

Aber eine Möglichkeit, die Verwendung der Klasse einfach zu machen, wäre sowas wie

```
import java.math.*;


class Rechteck
{
    protected double seitenlaenge_A;
    protected double seitenlaenge_B;
    protected double flaeche;
    protected double umfang;
    protected double diagonale;

    private boolean setA = false;
    private boolean setB = false;
    private boolean setArea = false;
    private boolean setCirc = false;
    private boolean setDiag = false;
    private boolean computed = false;

    public double getSeitenlaenge_A() {
        compute();
        return seitenlaenge_A;
    }

    public void setSeitenlaenge_A(double seitenlaenge_A) {
        this.seitenlaenge_A = seitenlaenge_A;
        setA = true;
    }

    public double getSeitenlaenge_B() {
        compute();
        return seitenlaenge_B;
    }

    public void setSeitenlaenge_B(double seitenlaenge_B) {
        this.seitenlaenge_B = seitenlaenge_B;
        setB = true;
        computed = false;
    }

    public double getFlaeche() {
        return flaeche;
    }

    public void setFlaeche(double flaeche) {
        this.flaeche = flaeche;
        setArea = true;
    }

    public double getUmfang() {
        compute();
        return umfang;
    }

    public void setUmfang(double umfang) {
        this.umfang = umfang;
        setCirc = true;
    }

    public double getDiagonale() {
        compute();
        return diagonale;
    }

    public void setDiagonale(double diagonale) {
        this.diagonale = diagonale;
        setDiag = true;
    }


    private void compute()
    {
        if (setA && setB)
        {
            flaeche = this.seitenlaenge_A*this.seitenlaenge_B;
            diagonale = Math.sqrt(seitenlaenge_A * seitenlaenge_A + seitenlaenge_B*seitenlaenge_B);
            umfang = 2 * seitenlaenge_A + 2 * seitenlaenge_B;
        }
        else if (setA && setArea)
        {
            this.seitenlaenge_B = flaeche / seitenlaenge_A;
            diagonale = Math.sqrt(seitenlaenge_A * seitenlaenge_A + seitenlaenge_B*seitenlaenge_B);
            umfang = 2 * seitenlaenge_A + 2 * seitenlaenge_B;
        }
        else if (setB && setArea)
        {
            this.seitenlaenge_A = flaeche / seitenlaenge_B;
            diagonale = Math.sqrt(seitenlaenge_A * seitenlaenge_A + seitenlaenge_B*seitenlaenge_B);
            umfang = 2 * seitenlaenge_A + 2 * seitenlaenge_B;
        }
        else
        {
            System.err.println("Input configuration not sufficient / not supported");
        }
    }


    public static void main(String[] args) {
       Rechteck rect = new Rechteck();
       rect.setSeitenlaenge_B(10);
       rect.setFlaeche(25);

       System.out.println("a= "+ rect.getSeitenlaenge_A());
       System.out.println("b= "+ rect.getSeitenlaenge_B());
       System.out.println("A= "+ rect.getFlaeche());
       System.out.println("d= "+ rect.getDiagonale());
       System.out.println("U= "+ rect.getUmfang());

       System.out.println("");

       rect = new Rechteck();
       rect.setSeitenlaenge_A(10);
       rect.setSeitenlaenge_B(20);

       System.out.println("a= "+ rect.getSeitenlaenge_A());
       System.out.println("b= "+ rect.getSeitenlaenge_B());
       System.out.println("A= "+ rect.getFlaeche());
       System.out.println("d= "+ rect.getDiagonale());
       System.out.println("U= "+ rect.getUmfang());

       System.out.println("");

       rect = new Rechteck();
       rect.setSeitenlaenge_A(10); // Reicht nicht!

       System.out.println("a= "+ rect.getSeitenlaenge_A());
       System.out.println("b= "+ rect.getSeitenlaenge_B());
       System.out.println("A= "+ rect.getFlaeche());
       System.out.println("d= "+ rect.getDiagonale());
       System.out.println("U= "+ rect.getUmfang());
    }
}
```

Das ist nur schnell hingeschrieben, um zu verdeutlichen, was ich meine! (Das könnte man noch VIEL schöner machen.... Diese ganzen Flags könnte man umgehen, indem man nicht "double" sondern "Double" verwendet, und dann prüft, welche Werte 'null' sind, aber ... naja)

Um so eine Funktion wie die 'compute()'-Methode (die in obigem Beispiel nur unvollständig bzw. für 3 einfache Fälle angedeutet ist) wirst du wohl kaum drumrumkommen. Vielleicht ist die Frage, ob diese Entscheidungen vom GUI getroffen werden, und dann eine von 30 Methoden der Rechteck-Klasse aufgerufen wird, oder ob die Entscheidungen von der Klasse getroffen werden (und der Benutzer dann nur eine oder zwei von 5 Methoden aufrufen muss) garnicht so wichtig, aber es gilt im Allgemeinen, dass eine Klasse so wenige public-Methoden haben sollte wie möglich, und so viele, wie nötig sind, um die Klasse vollständig "steuern" zu können.


----------

