public class Rechteck {
// Es gibt viele Möglichkeiten, wir wählen als Attribute:
private Punkt middle; // Mittelpunkt des Rechtecks
private int halfwidth; // Halbe Breite des Rechtecks
private int halfheight; // Halbe Höhe des Rechtecks
// Halbe Breite und Höhe erleichtert uns das Ausrechnen der Ecken.
/**
* Erstellt das Rechteck, welches von 2 Punkten aufgespannt wird.
*
* @param a
* Eine Ecke des neuen Rechtecks
* @param b
* Die gegenüberliegende Eckes des neuen Rechtecks
*/
Rechteck(Punkt a, Punkt b) {
// Wir klonen den Punkt a. (Klonen=Vollständig kopieren)
int ax = a.getX();
int ay = a.getY();
this.middle = new Punkt(ax, ay);
// Und verschieben ihn um die Hälfte des jeweiligen Achsen-Abstandes
int dx = (ax - b.getX()) / 2;
int dy = (ay - b.getY()) / 2;
this.middle.move(-dx, -dy);
// Der Betrag der Verschiebung liefert uns gleich die halbe Breite und
// Höhe
this.halfwidth = Math.abs(dx);
this.halfheight = Math.abs(dy);
}
/**
* Alternativer Konstruktor
*
* @param r Ein Rechteck, welches geklont wird, d.h. es besteht keine Verbindung zwischen neuem und altem Rechteck Objekt.
*
*/
Rechteck(Rechteck r) {
// Achtung Falle: "this.middle = r.middle" ist falsch,
// da Verschiebung des einen Rechtecks plötzlich auch das andere
// Verschieben würde;
// es muss ein neuer Punkt erzeugt werden! Es sei an Aufgabe 6-2
// erinnert!
this.middle = new Punkt(r.middle);
this.halfheight = r.halfheight;
this.halfwidth = r.halfwidth;
}
/**
*
* @return Liefert die X-Koordinate des Mittelpunktes
*/
public int getX() {
return this.middle.getX();
}
/**
*
* @return Liefert die Y-Koordinate des Mittelpunktes
*/
public int getY() {
return this.middle.getY();
}
/**
*
* @return Liefert die Breite des Rechtecks
*/
public int getWidth() {
return (2 * this.halfwidth);
}
/**
*
* @return Liefert die Höhe des Rechtecks
*/
public int getHeight() {
return (2 * this.halfheight);
}
/**
*
* @param dx
* Verschiebt das Rechteck um dx in der X-Koordinate
*
* @param dy
* Verschiebt den Rechteck um dy in der Y-Koordinate
*/
public void move(int dx, int dy) {
this.middle.move(dx, dy);
}
/**
* Verschiebt das Rechteck um seine eigene Breite nach rechts
*/
public void moveWidth() {
this.middle.move(2 * this.halfwidth, 0);
}
/**
*
* @param p
* Ein Punkt, zu dem die Distanz vom Mittelpunkt aus berechnet
* werden soll
*
* @return Berechnete Distanz des Mittelpunktes zum gegebenen Punkt
*/
public double distance(Punkt p) {
return this.middle.distance(p);
}
/**
* Halbiert beide Kanten des Rechtecks; der Mittelpunkt bleibt unver\"andert
*/
public void half() {
this.halfheight /= 2;
this.halfwidth /= 2;
}
/**
*
* @return Liefert linke obere Ecke (kleinste Kooridnaten) des Rechtecks als neuen Punkt
*/
public Punkt getUpperLeft() {
Punkt p = new Punkt(this.middle);
p.move(-this.halfwidth, -this.halfheight);
return p;
}
/**
*
* @return Liefert rechte untere Ecke (groesste Kooridnaten) des Rechtecks als neuen Punkt
*/
public Punkt getLowerRight() {
Punkt p = new Punkt(this.middle);
p.move(this.halfwidth, this.halfheight);
return p;
}
/**
* Verschiebt das Rechteck bündig zur linken obere Ecke (kleinste Koordinaten) eines gegebenen
* Rechtecks
*
* @param l
* Rechteck mit dessen linker oberer Ecke (kleinste Koordinaten) bündig geschoben
* werden soll
*/
public void alignUpperLeft(Rechteck ll) {
Punkt p = ll.getUpperLeft();
p.move(this.halfwidth, this.halfheight);
this.middle = p;
}
/**
* Skaliert Breite und Höhe des Rechtecks, ohne Prüfung auf Sonderfälle wie negative Faktoren
* @param fx Faktor zur Skalierung der Breite
* @param fy Faktor zur Skalierung der Höhe
*/
public void scale(int fx, int fy) {
halfwidth *= fx;
halfheight *= fy;
}
/**
* Vergrößert das Rechteck zum kleinstmöglichen Quadrat,
* in welches das Rechteck noch hineinpasst,
* ohne den Mittelpunkt des Rechtecks zu verschieben.
*/
public void square() {
if (this.halfwidth < this.halfheight) {
this.halfwidth = this.halfheight;
} else {
this.halfheight = this.halfwidth;
}
}
}
