Ein Quadrat ist eine Spezialisierung von einem Rechteck, demnach wäre eine Möglichkeit zu sagen, dass Quadrat eine Unterklasse von Rechteck ist.
Such in dem Zusammenhang mal nach "Liskov Substitution Principle", bzw. Brechung desselben.Marco13 hat gesagt.::lol: Das hat mich eben auch mal dazu veranlasst, das große goOrakel zu fragen
"Square extends Rectangle": ca. 1000 Ergebnissse
"Rectangle extends Square": ca. 100 Ergebnisse
Marco13 hat gesagt.:
public class Rectangle {
private int width;
private int height;
public int getHeight() { return height; }
public int getWidth() { return width; }
public void setHeight(int p) { height=p; }
public void setWidth(int p) { width=p; }
}Niki hat gesagt.:
public class Tools {
/**
* Verzerrt ein beliebiges Rechteck zu einem flächengleichen Einheitsrechteck mit der Breite 1.
* VORBEDINGUNG: rec ist ein Rechteck, width und height sind größer als 0.
* NACHBEDINGUNG: rec hat width=1 und eine unveränderte Gesamtfläche.
*/
public static void einheitsRechteck(Rectangle rec) {
int flaeche = rec.getWidth()*rec.getHeight();
rec.setWidth(1);
rec.setHeight(flaeche);
}
} public static Rectangle einheitsRechteck(Rectangle rec) {
int flaeche = rec.getWidth()*rec.getHeight();
rec = new Rectangle();
rec.setWidth(1);
rec.setHeight(flaeche);
return rec;
}
Das wäre nur ein Workaround. Es ist wie gesagt nur ein einfaches Beispiel. In anderen Fällen ist es vielleicht nicht möglich, sich so leicht zu helfen. Deswegen sollte man sich immer an das LSP halten: Ein Subtyp muss unter allen Umständen an Stelle des Obertyps verwendet werden können.Niki hat gesagt.:
Marco13 hat gesagt.:
public abstract class Shape {
public int getArea();
}
public class Rectangle extends Shape {
private int width;
private int height;
public Rectangle(int width, int height) { this.width=width; this.height=height; }
public int getHeight() { return height; }
public int getWidth() { return width; }
public void setHeight(int p) { height=p; }
public void setWidth(int p) { width=p; }
public int getArea() { return height*width; }
}
public class Square extends Shape {
private int size;
public Square(int size) { this.size = size; }
public int getSize() { return size; }
public void setSize(int p) { size=p; }
public int getArea() { return size*size; }
}Ja, aber wie sieht es mit der Fortpflanzung aus?
public abstract class Shape {
public int getArea();
}
public class Rectangle extends Shape {
private int width;
private int height;
public Rectangle(int width, int height) { this.width=width; this.height=height; }
public int getHeight() { return height; }
public int getWidth() { return width; }
public void setHeight(int p) { height=p; }
public void setWidth(int p) { width=p; }
public int getArea() { return height*width; }
}
public class Square extends Shape {
private Rectangle rectangle;
public Square(int size) { rectangle = new Rectangle(size, size); }
public int getSize() { return rectangle.getWidth(); }
public void setSize(int p) { rectangle.setHeight(p); rectangle.setWidth(p); }
public int getArea() { return rectangle.getArea(); }
}Zu trivial, da das zwei vollkommen getrennte Klassen sind, die nichts miteinander zu tun haben, weil man das getArea auch weglassen könnte, und die beiden dann (Juchhu...) ja immernoch von Object erben. Solange die Objekte (aus Sicht der abstrakten Oberklasse!) "immutable" sind, ist das "raushauen" schwierig.tfa hat gesagt.:
:meld: :autsch:Ein Quadrat ist aber ein Rechteck!?!tfa hat gesagt.:
boolean isSquare() {}Nein, ist es nicht (siehe oben).ms hat gesagt.:
ms hat gesagt.:
public class Rectangle {
...
public static Rectangle createSquare(int) {...}
public boolean isSquare() {...}
}Um an irgendeiner Stelle damit zu arbeiten? Klar, wenn Du in Deinem Kontext nie Quadrate von Rechtecken unterscheiden musst, dann brauchst Du auch kein Quadrat zu definieren. Aber vielleicht brauchst Du ja in einem Kontext nur Quadrate, in einem anderen nur Rechtecke und in noch einem anderen beides.ms hat gesagt.:
dem würde ich so nicht ohne erläuterung folgen wollen.tfa hat gesagt.:
public class Quadrat extends Rechteck {
public Quadrat(double kantenlaenge) {
super(x,x);
}
}ähhhh...klar geht es darum.tfa hat gesagt.:
Naja, keine gute Idee.byto hat gesagt.:
tfa hat gesagt.:
public class Tools {
public static void checkRectangle(Rectangle rec) {
rec.setWidth(3);
rec.setHeight(4);
if (rec.getArea() != 12) {
// Boom
}
}
}spezialisierungen auf attributebene zu begründen widerspricht jeglicher OOP!tfa hat gesagt.:
SlaterB hat gesagt.:warum so kompliziert?
Code:public class Tools { public static void checkRectangle(Rectangle rec) { rec.setWidth(3); rec.setHeight(4); if (rec.getArea() != 12) { // Boom } } }
@Test
public void test1() {
Rectangle rec = new Rectangle(1,2);
rec.setWidth(3);
rec.setHeight(4);
assertEquals( rec.getArea(), 12);
}
@Test
public void test2() {
Rectangle rec = new Square(1);
rec.setWidth(3);
rec.setHeight(4);
assertEquals( rec.getArea(), 12);
}| Titel | Forum | Antworten | Datum | |
|---|---|---|---|---|
| M | Wie tief darf eine Vererbungshierarchie sein? | Softwareentwicklung | 10 |
