I would perhaps eg. define protected abstract class Dims in Rectangle, which has intance variables width and height and setters for them. Then Rectangle has inner private class that extends/imlements that class. Rectangle has also setters and getters for width and height, where dimensions is manipulated through Dims instance.

Now, Square inherits Rectangle and has inner private class that inherits Dims and overrides setters, where width and height is set the same.

So what is really changed in Square, is just one implementation of abstract class, that is not exposured by Rectangle-api.

That was not very good explanation, sorry, but my example works:

public class Rectangle {
protected Dims dims;

public Rectangle() {
dims = new RecDims(0, 0);
}

public Rectangle(int width, int height) {
dims = new RecDims(width, height);
}

public int getWidth() { return dims.width; }
public int getHeight() { return dims.height; }

public void setWidth(int wid) { dims.setWidth(wid); }
public void setHeight(int hei) { dims.setHeight(hei); }

private class RecDims extends Dims {
public RecDims(int wid, int hei) {
width = wid;
height = hei;
}
}

protected abstract class Dims {

public int width;
public int height;

public void setWidth(int wid) { width = wid; }
public void setHeight(int hei) { height = hei; }
}

}

public class Square extends Rectangle {

public Square(int dim) {
dims = new SquDims(dim);
}

private class SquDims extends Dims {

public SquDims(int dim) {
width = dim;
height = dim;
}

public void setWidth(int wid) { width = wid; height = wid; }
public void setHeight(int hei) { height = hei; width = hei; }
}

}

Although people try to use mathematical arguments about types, types play little role in mathematics. Neither “Square” nor “Rectangle” would be thought of as a type. There is a set of all Rectangles, which has a subset of all Squares. Because Square is a subset, any function whose *domain* is Rectangle is defined for all members of Square. On the other hand, there’s no particularly interesting connection between functions whose *range* is Rectangle and functions whose *range* is Square. It may be interesting to prove that some function described as having a range of Rectangle actually only produces Squares, but that’s proving something about the function, not talking about types. Mutability isn’t strictly an issue – in using English, a mathematician will certainly say things like “doubling the length of the sides of a Square multiplies the area by 4″, which *sounds* like the square is being modified, even to a mathematician. Formally, though, if you pushed, we can describe the same thing functionally – we have a function from Square to Square that gives you a new square (this is itself just an informal phrase!). A function that only doubled the horizontal dimension would go from Square to Rectangle. No big deal. You can recast your classes to be immutable, but as long as you have functions that return new, modified instances, you have the same problems.

LSP is a fine idea, but it only goes so far. If I have a “typeof” operator that returns the dynamic type, no class is really substitutable for another, because they produce different results from “typeof”. Does that bother you? The whole notion of “isa” as the defining relationship for subclasses/subtypes fails for the same reason.

Programming isn’t mathematics. Subclassing and even subtyping are programming concepts, not mathematical concepts, though there’s a fine mathematical theory of types developed exactly to help you understand the implications of choosing a style of subclassing/subtyping/genericity/etc. If you’re concerned about displaying geometric objects – where this whole discussion usually arises – then thinking of a Square as a “kind of” Rectangle which is a “kind of” Polygon which is a “kind of” Shape is useful. Once you begin thinking about what kinds of mutators are appropriate, things get much more interesting. Consider a graphical editor: If I create a Square, then grab it and resize it, do I expect it to stay square, or can I stretch it one way and make it a Rectangle? Now you’re talking neither mathematics nor programming – you’re talking UI design and user expectations.

— Jerry

Not even in your dreams

——————
Minor nit:

If
-> Rectangle extends Square with setHeight, setWidth
then
-> Shape extends Square, Rectangle, Circle, … with setSize, setHeight, setWidth, setRadius, …

——————
Major nit:

class Square …

class Rectangle extends Square…

Square sq = new Rectangle(10, 5);

oops….

——————
Really, this thread leads to the conclusion that for IS-A what we really want is:

class Rectangle…

class Square restricts Rectangle…

Our intuition about rectangles and squares is as immutable objects. If you try to model this, then indeed ImmutableSquare is a subclass of ImmutableRectangle and it should use constructors. If you want mutation, then a Square is a 1-parameter shape and a rectangle is a 2-parameter shape. These are clearly not the same. Here’s a way:

public abstract class MutableShape;

private Integer numberOfParameters;

private double[] parameters;

MutableShape(Integer numberOfParameters, double… parameters);

if (numberOfParameters >= 0) {

this.numberOfParameters = numberOfParameters;

setParameters(parameters);

}

else throw new IllegalArgumentException(“numberOfParameters must be non-negative”);

}

void setParameters(double… parameters) {

if (parameters.length == numberOfParameters)

this.parameters = parameters;

else throw new IllegalArgumentException(“wrong number of parameters”);

}

public double[] getParameters() { return parameters; }

public abstract double getArea();

}

—————————-

public class Square extends MutableShape {

public Square(double size) {

super(1, size);

}

public void setSize(double size) { getParameters()[0] = size; }

public double getSize() { return getParameters()[0]; }

public double getArea() {

double size = getSize();

return size * size;

}

}

—————————-

public class Rectangle extends MutableShape {

public Rectangle(double height, double width) {

super(2, height, width);

}

public double getHeight() { return getParameters()[0]; }

public double getWidth() { return getParameters()[1]; }

public void setHeight(double height) { getParameters()[0] = height; }

public void setWidth(double width) { getParameters()[1] = width; }

public double getArea() {

return getHeight() * getWidth();

}

public boolean isSquare() { return getHeight() == getWidth(); }

public Square toSquare() {

return isSquare() ? new Square(getHeight()) : null;

}

I definitely have to go with Johann’s train of thought.
This would result in the following :

* all classes immutable. You cannot modify an object, merely create a new one.

*class Rectangle with methods
constructor: Rectangle( width, height)
Rectangle scale( percentage );
Rectangle reshapeWidth( width )
Rectangle reshapeHeigth( height)

*class Square extends Rectangle with methods:
constructor: Square(width)
constructor: Square( Rectangle )
Square scale( percentage );
Rectangle reshapeWidth( width)
Rectangle reshapeHeight( height )
boolean isSquare( Rectangle )

-if you want to create a square with a new specific height, use the constructor.

-If you modify the width/height of an existing Square or Rectangle a new Rectangle object will be the result.

-When you scale a Square a new Square will result. When you scale a Rectangle a new Rectangle will result.

How about calling the method ’scale’ ?

You take the class Square and merely give it the method scale.

The class Rectangle then extends Square and adds the operations scalewidth and scaleHeight.

m2ndSquare = Square.isSquare(myRectangle) ? new Square(myRectangle) : null;

mathematically speaking:
– a rectangle is a (convex) polygon with 4 orthogonal edges
– a square adds another constraint: all sides same length
– both are immutable
– a geometrical transformation transforms each point one-by-one
– is is known, what transformations results are what kind of a shape

But:
– you will not resize a shape in mathematics, by resizing its length but by resizing its points, for rectangles the vertexes and redraw the edges
– setting the height or width of a rectangle is not a simple operation, it is a transformation on an infinite number of points

So:
– you simplified the mathematical rectangle to something named the same way, but have implemented the transformations wrong. Setting the height on a square will make it a different polygon, it will be a common rectangle.
– setting height, than width on a rectangle simply is a set of consecutive operations/transformations, which do not preserve the shape, but happen to result in the same shape after doing both with carefully chosen new values.
– what about choosing stretchHeight as the name for setHeight?

I don’t see a problem with overriding the setHeight() and setWidth() rectangle arguments to make a square, if you wanted to make such a type. The immutable solution is nice, but limiting.