Java: weak pre condition and strong post condition, how to?

Question

I'm having a really hard time in understanding how pre-conditions and post-conditions must work, without violate the Substitution Principle. So let's assume that we have a class Rectangle and Square—how to relate them? Which one must be the subclass?

So I undertand that the pre-conditions of a Subtype can be weaker, that means that we can take a major 'set' of things in out subclass, on the other hand the post-condition can be stronger so we can return a minor 'set' of things. How can I appply these rules in my example?

I read that the baseclass must 'do' less than the subclass, so I think that Square must be our baseclass and Rectangle the subclass. Thus the pre-condition in Square must be assert that height == width, but what about the post-conditions and the pre-conditions in Rectangle?

Answer 1

A general way to find out super and subclasses, you basically need to answer this question:

Is every X a Y?

In you case you need to say these two things:

• Is every Rectangle a Square? No.
• Is every Square a Rectangle? Yes.

Thus Square is a Rectangle. Then the condition for becoming Square is:

• If it's a rectangle; and
• the height equals the width.

Answer 2

You need to understand every square is a rectangle but every rectangle is not a square.

Condition you need for rectangle is its has 4 size not less not more and any three angles are 90 degrees.

In code they should be 2 different classes. I haven't defined polygon class but you get the concept of it.

Eg :

public class Quadrilateral extends Polygon {
    ...
}

Next :

public class Rectangle extends Quadrilateral {
    private double length;
    private double breadth;

   public Rectangle (double len, double brd ) {...}

}

Then square :

public class Square extends Rectangle {
    private double side;
    public Square (double sideLength) {
         super(sideLength, sideLength);
    }
}

Answer 3

Actually it's the otherway round. Square is a SubClass of Rectangle. Why? Every Square 'is a' Rectangle, but not every Rectangle 'is a' Square.

You can extend this inheritance relation further, every GeometricShape is an Object, every Polygon is a GeometricShape, every Quadrangle is a Polygon, every Rectangle is a Quadrangle, etc. The further you go down the inheritance hierarchy, the more constraints are added, making the subclasses more special, than the parent classes.

What is a contraint of a Rectangle? Every corner has a rectangular agle (90°), what is the the constraint of a Square? Its a rectangle (90°) with every edge being of the same length.

Answer 4

Subtyping

A subclass, or child class, is always a specialized type of the base class, or superclass.

Java uses the keyword extends, because the subclass actually extends the superclass, often adds functionality.

A square is a special, that is, more specific type of a rectangle. It is a rectangle, but with the additional property that the height equals the width.

---

Liskov Substitution Principle

However, the Substitution Principle – I'm guessing that you mean the Liskov Substitution Principle – states that anywhere where you would expect a certain class (in our case Rectangle), you should be able to use a subtype of that class (in our case Square), without breaking the functionality or logic. If you're not, the design violates the Liskov Subtitution Principle.

I can give an example, but it is already written in this answer. Note that this answer uses the classes you mentioned.

So, to summarize, it sounds logical that a square is a specialized type of a rectangle, but according to the Liskov Substitution Principle, it is bad abstraction.

So yes, declaring Square as subclass of Rectangle fails the Liskov Substitution Principle.

Note that they also wrote a Wikipedia page about it. It's a very common problem.

Answer 5

• Rectangle is subclass of Square. Reason being, rectangle is a weaker form of square: it has weaker preconditions.
• Square preconditions: four sides, all adjoining at 90 degree, all sides equals.
• Rectangle has only first two preconditions. Will these two behave same for client code? Yes.
• Square: getArea() {return side*side}
• Rectangle:
  • getArea() {return l * w} << same interface Square constructor:
• Square(int side) Rectangle constructor 1:
• Rectangle(int side){l = side; w = side;} << same interface as square
• Rectangle constructor 2:
  • Rectangle(int l, int w){this.l = s; this.w = w} << new addition
• Why is rectangle allowed to have an extra constructor? Because it extends square, and therefore can add functionality, but cannot restrain functionality of superclass.