# Klassenkonzept - Kreis (Umfang, Flaeche)



## 5c4r3 (11. Sep 2011)

Hallo zusammen.
Ich stehe gewaltig auf dem Schlauch nach dem neuen Thema "Klassenkonzept".
Folgende Aufgabenstellung:

Erstellen Sie die Klasse Kreis mit allen set und get Methoden.

Ich bin davon ausgegangen das ich es verstanden hätte, seht am besten selbst:


```
public class MainKreis 
{
	public static void main(String[] args) 
	{
		Kreis radius = new Kreis();
		radius.setRadius(5);
		System.out.println(radius.getUmfang());
		System.out.println(radius.getFlaeche());
	}
}
```


```
public class Kreis 
{
	private double umfang;
	private double flaeche;
	
	public void setUmfang(double umfang)
	{
		umfang = 2*Math.PI*radius;
	}
	public double getUmfang()
	{
		return this.umfang;
	}
	
	public void setFlaeche(double flaeche)
	{
		flaeche = Math.PI*Math.sqrt(radius);
	}
	public double getFlaeche()
	{
		return this.flaeche;
	}
}
```


Kann mir mal bitte jemand erklären, oder einen Anhaltspunkt geben, was daran falsch ist?


----------



## Marco13 (11. Sep 2011)

Die Methode "setRadius" gibt es nicht. Und eigentlich bräuchte man nur die, weil die anderen Dinge sich daraus Berechnen lassen. Aber natürlich wäre es praktisch, wenn man auch "setUmfang" oder so hätte. Das kann aber nicht so ablaufen, wie es da jetzt anskizziert ist. Als Tipp: Die Klasse braucht nur EIN Field (Variable), nämlich "radius". Und wenn man "setUmfang" aufruft, wird der 'radius' so verändert, dass der Kreis den angegebenen Umfang hat.


----------



## 5c4r3 (12. Sep 2011)

Bahnhof!

Also kann ich Umfang und Fläche aus der Klasse komplett entfernen?
Wo findet denn später die Berechnung statt?
Das der Radius in der Klasse MainKreis definiert wird ist aber doch richtig?


----------



## Final_Striker (12. Sep 2011)

> Also kann ich Umfang und Fläche aus der Klasse komplett entfernen?


Du kannst die set-Methoden entfernen.



> Wo findet denn später die Berechnung statt?


In den get-Methoden oder in der setRadius Methode.


----------



## Marco13 (12. Sep 2011)

@Final_Striker: Die Setter können ruhig drin bleiben...

@5c4r3: In diesem Fall lassesn sich ALLE Eigenschaften des Kreises aus ALLEN anderen berechnen. Wenn man den Radius hat, kann man daraus Umfang und Fläche Berechnen. Wenn man die Fläche hat kann man daraus Umfang und Radius berechnen, usw. Es bietet sich darum an, nur EINE dieser drei Eigenschaften (am besten den Radius) wirklich zu speichern. Die Berechnung des Umfanges kann dann direkt in der getUmfang-Methode passieren. (Als nächsten Schritt könnte man dann in einer setUmfang-Methode aus dem übergebenen Umfang den Radius berechnen, der gespeichert werden soll, aber du kannst ja mal mit dem ersten Teil anfangen)


----------



## Andi_CH (12. Sep 2011)

Es wurde so ähnlich gesagt: Speichere niemals mehr Werte als du wirklich brauchst.
Im Falle des Kreises ist das genau ein Wert.
Die Macht des Informationhiding liegt eben darin, dass du das irgendwann umstellen kannst ohne dass das von aussen jemand bemerkt.

Die erste Version von Kreis speichert den Radius, die Zweite den Umfang - selbstverständlich könnte auch der Durchmesser oder die Fläche gespeichert werden. Du kannst in einem Programm ohne Aufwand die Klasse Kreis durch die andere Variante ersetzen.


```
public class Kreis {
	private double mRadius;

	public void setUmfang(double umfang) {
		mRadius = (umfang / Math.PI) / 2.0;
	}
	public double getUmfang() {
		return 2.0 * mRadius * Math.PI;
	}
	public void setFlaeche(double flaeche) {
		mRadius = Math.sqrt((flaeche / Math.PI));
	}
	public double getFlaeche() {
		return mRadius * mRadius * Math.PI;
	}
	public  void setRadius(double radius) {
		mRadius = radius;
	}
	public double getRadius() {
		return mRadius;
	}
}
```

oder z.B. so


```
public class Kreis {
	private double mUmfang;

	public void setUmfang(double umfang) {
		mUmfang = umfang;
	}
	public double getUmfang() {
		return mUmfang;
	}
	public void setFlaeche(double flaeche) {
		double radius = Math.sqrt((flaeche / Math.PI));
		mUmfang = 2.0 * radius * Math.PI;
	}
	public double getFlaeche() {
		double radius = mUmfang / (2.0 * Math.PI);
		return radius * radius * Math.PI;
	}
	public  void setRadius(double radius) {
		mUmfang = 2.0 * radius * Math.PI;
	}
	public double getRadius() {
		return (mUmfang / Math.PI) / 2.0;
	}
}
```


----------



## 5c4r3 (12. Sep 2011)

Vielen Dank erstmal an alle für die Hilfe.
Hab es jetzt soweit hinbekommen:


```
public class mainKreis 
{
	public static void main(String[] args) 
	{
		Kreis radius = new Kreis();
		radius.setRadius(10);
		System.out.println("Umfang: "+ radius.getUmfang());
		System.out.println("Flaeche: "+ radius.getFlaeche());
	}
}
```


```
public class Kreis 
{
    private double radius; 
    public double getUmfang() 
    {
        return 2*radius*Math.PI;
    }
    public double getFlaeche() 
    {
        return Math.pow(radius,2)*Math.PI;
    }
    public  void setRadius(double radius) 
    {
       this.radius=radius;
    }
}
```


Zum Verständnis, in der Klasse mainKreis wird der Variable "radius" ein Wert zugewiesen mit "radius.setRadius(10);". In der Klasse Kreis wird dann mit "this.radius=radius" der Wert wieder gesetzt und "getUmfang" sowie "getFlaeche" wird der Wert jeweils ermittelt und sofort ausgegeben, also nicht gespeichert?

Seht ihr in dem Quellcode Fehler die man vermeiden sollte? Würde das nämlich gerne als Beispiel benutzen für eine nächste Aufgabe "Rechteck".


----------



## 5c4r3 (12. Sep 2011)

Habe jetzt mal ein Programm für die Berechnung eines Rechtecks geschrieben (Verbesserungsvorschläge?):


```
public class mainRechteck 
{
	public static void main(String[] args) 
	{
		Rechteck objekt = new Rechteck();
		objekt.setHoehe(2);
		objekt.setBreite(4);
		System.out.println("Flaeche: "+ objekt.getFlaeche());
		System.out.println("Umfang: "+ objekt.getUmfang());
	}
}
```


```
public class Rechteck 
{
	private double hoehe, breite;
	
	public  void setHoehe(double hoehe) 
	{
      this.hoehe=hoehe;
	}
	public  void setBreite(double breite) 
	{
      this.breite=breite;
	}
	public double getFlaeche()
	{
		return hoehe*breite;
	}
	
	public double getUmfang()
	{
		return (2*hoehe)+(2*breite);
	}
}
```


----------



## Marco13 (12. Sep 2011)

Nö, vom Grundansatz her passt das so. (Soll nicht heißen dass man nicht stundenlang darüber philosophieren und daran rumkritisieren könnte, aber das können gerne andere übernehmen  )


----------



## Andi_CH (13. Sep 2011)

Mach doch noch einen Konstruktor mit dem du gleich hoehe und breite setzten kannst.

Und denk mal darüber nach ob es gut ist für Paramter und Variablen die gleichen Namen zu verwenden.
Ich sage ganz klar: Es darf keine gleichen Namen geben - die Verwechslungsgefahr ist zu gross.

(ja, die mit dem zu kleinen geistigen Horizont um die Vor- und Nachteile zu erfassen dürfen jetzt wieder ....)


----------

