# Fläche von Rechtecken



## Derenei (26. Mai 2012)

Hier die Aufgabenstellung:

Schreibe ein Programm, das die Fläche von Rechtecken berechnet. Folgende 3 Klassen sind zu programmieren:

1) Klasse Point: enthält die beiden Koordinaten eines Punktes. Schreibe einen passenden Konstruktor und eine Methode print(), die die Koordinaten des Punktes auf die Konsole ausgibt. Eine statische Variable soll mitzählen, wieviele Punkte erzeugt wurden.

2) Klasse Rectangle: enthält 2 Objekte des Typs Point als Variable. Schreibe einen Konstruktor, der ein Rechteck aus 2 Parametern des Typs Point (linke obere Ecke und rechte untere Ecke des Rechtecks) erzeugt und einen, der ein Rechteck aus 4 int-Werten (jeweils 2 x u. y-Koordinaten) erzeugt. Auch hier soll es eine Methode print() geben, die die Punkte des Rechtecks auf die Konsole ausgibt (es sollen als in dieser Methode die print-Methoden von Point aufgerufen werden). Eine statische Variable soll mitzählen, wieviele Rechtecke erzeugt wurden.
Die Methode area() soll die Fläche des Rechtecks zurückgeben (zeichne eine kleine Skizze, dann sollte sofort klar sein, wie man die Fläche berechnen kann).

Erstelle für die Klassen Point und Rectangle eine sinnvolle JavaDoc!

3) Klasse RectangleProgram als Hauptprogramm. Es sollen 2 Punkte von der Konsole eingelesen werden und damit ein Rectangle erzeugt werden. Dieses soll dann auf die Konsole ausgegeben werden. Danach soll die Fläche berechnet und ebenfalls ausgegeben werden.


.....


Mein Programm funktioniert schon teilweise, und zwar habe ich die Point Klasse fertig programmiert, bei der Rectangle Klasse verstehe ich aber die Aufgabestellung nicht ruchtig. Ich habe den ersten Konstrukter fertig programmiert der die zwei Point Objekt bekommt, die Methode area () berechnet auch schon die Fläche. Dann steht aber weiter im Punkt zwei das man einen Konstrukter porgrammieren soll der vier  int-Werten (jeweils 2 x u. y-Koordinaten) bekommt. Ich verstehe das mit den vier int Werten nicht, die Klasse bekommt ja nur zwei objekte des Typs Point.


Hier mein bereitsgemachter Quellcode:

Point Klasse:


```
class Point
{
    int x;
    int y;
    
    static int counter = 0;
    
    public Point (int x, int y)
    {
        this.x = x;
        this.y = y;
        
        counter ++;
    }
    
    public void print ()
    {
        Out.print ("("+this.x+"/"+this.y+")");
    }
}
```

Rectangle Klasse


```
class Rectangle
{
    Point a, b;
    int length, high;
    
    static int counter;
    /**
     * Bekommt zwei Objekte des Types point
     */
    public Rectangle (Point a, Point b)
    {
        this.a = a;
        this.b = b;
        counter++;
        
        length = b.x-a.x;
        high = b.y-a.y;
    }
    
    public int area ()
    {
        int area = length*high;
        return area;
    }
}
```

RectangleMain


```
class RectangleProgram
{
    public static void main ()
    {
        int x,y;
        
        Out.println ("Rechtecks Flächenberechner");
        Out.println ();
        
        Out.print ("Geben Sie die erste x-Koordinate ein: ");
        x = In.readInt ();
        Out.print ("Geben Sie die erste y-Koordinate ein: ");
        y = In.readInt ();
        Point a = new Point (x, y);
        
        Out.print ("Geben Sie die zweite x-Koordinat ein: ");
        x = In.readInt ();
        Out.print ("Geben Sie die zweite y-Koordinat ein: ");
        y = In.readInt ();
        Point b = new Point (x, y);
        
        Out.println ();
        Out.print ("A");
        a.print ();
        Out.print (" B");
        b.print ();
        
        Out.println ();
        Rectangle i = new Rectangle (a, b);
        Out.print ("Flächeninhalt des Rechtecks: "+i.area ());
    }
}
```

Danke im Voraus.

MFG


----------



## Gast2 (26. Mai 2012)

```
class Rectangle
{
    Point a, b;
    int length, high;
    [...]
    public Rectangle (Point a, Point b)
    {
        this.a = a;
        this.b = b;
        counter++;
        
        length = b.x-a.x;
        high = b.y-a.y;
    }

    public Rectangle (int x1, int y1, int x2, int y2) {
        this(new Point(x1, y1), new Point(x2, y2));
    }

    [...]
}
```


----------



## Derenei (26. Mai 2012)

Danke schön


----------



## faetzminator (26. Mai 2012)

Davon ausgegangen, dass die Punkte ggf. auch umgekehrt überwerden können sollten, würde ich bei der Flächenberechnung [c]abs()[/c] verwenden. Zusätzlich würde ich mir überlegen, ob du entweder gleich die Area oder nur die Points speichern willst. Einen Teil der Berechnung im Konstruktor und einen weiteren beim ausgeben zu machen, ist irgendwie komisch 

```
area = Math.abs((b.x - a.x) * (b.y - a.y));
```
Zusätzlich fehlt noch die Methode [c]print()[/c] (nicht [c]Print()[/c] ) in [c]Rectangle[/c].


----------



## Derenei (29. Mai 2012)

Jetzt bin ich leider wieder etwas verwirrt, der zweite Konstruktor bekommt die vier Int Werte und erzeugt damit dann zwei neue Point Objekte, ok soweit habe ich das verstanden, aber in der Aufgabenstellung steht das die Klasse zwei Objekt des Types Point bekommt aber wie soll ich dann der Klasse die vier Int Werte mitgeben ? ???:L

Danke im Voraus.

MFG


----------



## yyannekk (29. Mai 2012)

Die Klasse Rectangle hat jetzt zwei Konstruktoren. Einer erwartet zwei Points, der andere vier ints.
Das heißt wenn du ein Rectangle erzeugen willst überlegst du dir welchen Konstruktor du verwenden willst und rufst den dann mit den entsprechenden Parametern auf. Du kannst zB mit 
	
	
	
	





```
Rectangle r1 = new Rectangle(5,4,7,6);
```
oder mit 
	
	
	
	





```
Point a = new Point(4,3); Point b = new Point(6,5); Rectangle r2 = new Rectange(a,b);
```
 ein Rechteck erzeugen


----------



## Derenei (29. Mai 2012)

Danke für deine Antwort, ich habe mir das vorher auch so ähnlich überlegt, was mich aber verwirrt, ist das wenn man den zweiten konstruktor nutzen will der die vier Int Werte bekommt auch der Klasse vier Int Werte mitgeben muss, also habe ich jetzt in der Rectangle Klasse geschrieben:


```
Point a, b //für den ersten Konstruktor
int x1, y1, x2 , y2; //für den zweiten Konstruktor
```

... denn in der Angabe steht das die Klasse nur zwei Point Objekte bekommt mehr nicht.

Iregndwie verwirrend ???:L

Ich muss aber der Klasse vier Int Werte mitgeben, anders kann ich das Problem nicht lösen.

Danke für eure Antworten :toll:


----------



## yyannekk (29. Mai 2012)

Es geht einfach darum dass du jetzt zwei konstrultoren hast, und dir sozusagen aussuchen kannst welchen du benutzt.... Hast du gerade 4 int s parart benutzt du den int konstruktor. Hast du 2 point s benutzt du den anderen. Für dein beispiel ist es völlig egal.


----------



## Crian (30. Mai 2012)

Derenei hat gesagt.:


> Danke für deine Antwort, ich habe mir das vorher auch so ähnlich überlegt, was mich aber verwirrt, ist das wenn man den zweiten konstruktor nutzen will der die vier Int Werte bekommt auch der Klasse vier Int Werte mitgeben muss, also habe ich jetzt in der Rectangle Klasse geschrieben:
> 
> 
> ```
> ...



Nein, das brauchst du nicht, diese Werte x1, y1, x2, y2. Das, was der Konstruktor in



> ```
> Point a, b;
> int length, high;
> [...]
> ...


macht, ist den zweiten Konstruktor aufzurufen. schauen wir uns an, was genau passiert:

Ein Programm ruft den zweiten Konstruktor auf:

[c]Rectangle r = new Rectangle(1,2,3,4);[/c]

Nun wird die Zeile 

[c]this(new Point(x1, y1), new Point(x2, y2));[/c]

ausgeführt. Das [c]this[/c] vorne steht für den Aufruf eines Konstruktors. Dies geht in der ersten Zeile eines Konstruktors, einen anderen Konstruktor aufzurufen.

Schauen wir uns die Parameter des zweiten Konstruktoraufrufs an: 
	
	
	
	





```
new Point(x1, y1)
```
 und 
	
	
	
	





```
new Point(x2, y2)
```
.

Hier werden zwei neue Point-Objekte erzeugt und mit den übergebenen Parametern initialisiert.

Wir haben also einen 
	
	
	
	





```
Point(1,2)
```
 und einen 
	
	
	
	





```
Point(3,4)
```
.

Also findet ein Konstruktoraufruf statt, dem zwei Point-Objekte übergeben wurden. Ergo wird dein obiger konstruktor aufgerufen und die Übergebenen Koordinaten landen bereits in den Point-Objekten 
	
	
	
	





```
a
```
 und 
	
	
	
	





```
b
```
 deiner Klasse Rectangle.

Würde man die etwas kryptische Zeile des unteren Konstruktors auseinander nehmen, stände dort


```
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
this(p1, p2);
```

Das sieht einfacher und verständlicher aus. Allerdings gäbe es einen Kompilerfehler, da ein anderer Konstruktor nur in der ersten Zeile eines Konstruktors aufgerufen werden darf.


----------

