1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// The type system only checks SYNTACTIC compatibility
 
public class Rectangle {
    public void setWidth(int w) { ... }   // Signature: void setWidth(int)
    public void setHeight(int h) { ... }  // Signature: void setHeight(int)
}
 
public class Square extends Rectangle {
    @Override
    public void setWidth(int w) { ... }   // ✓ Same signature
    @Override
    public void setHeight(int h) { ... }  // ✓ Same signature
}
 
// Compiler says: "Square has all required methods with correct signatures"
// Compiler says: "Square IS-A Rectangle (structurally)"
// Compiler says: "Substitution is ALLOWED"
 
// But the compiler CANNOT verify:
// - Does Square.setWidth() honor Rectangle.setWidth()'s postconditions?
// - Does Square maintain Rectangle's invariant expectations?
// - Will client code behave correctly with Square in place of Rectangle?
 
// LSP demands SEMANTIC compatibility, which compilers can't check!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

/**
 * Rectangle.setWidth(int w) Contract Specification
 * 
 * @precondition: w >= 0
 *     The width must be a non-negative integer.
 * 
 * @postcondition: getWidth() == w
 *     After the method returns, getWidth() returns the value that was passed.
 * 
 * @postcondition: getHeight() == old(getHeight())
 *     The height is UNCHANGED by this operation.
 *     (This is the IMPLICIT but CRITICAL postcondition)
 * 
 * @postcondition: getArea() == w * old(getHeight())
 *     The area is updated to reflect the new width with unchanged height.
 * 
 * @invariant: (none specified by Rectangle)
 *     Rectangle does not require width == height or any similar constraint.
 */
public void setWidth(int w) {
    this.width = w;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

/**
 * Square.setWidth(int w) Contract Specification
 * 
 * @precondition: w >= 0
 *     Same as Rectangle — this is acceptable (not stronger).
 * 
 * @postcondition: getWidth() == w
 *     ✓ SATISFIED — width is set to w.
 * 
 * @postcondition: getHeight() == old(getHeight())
 *     ✗ VIOLATED! getHeight() is now equal to w, not the old height!
 *     This is where the LSP violation occurs.
 * 
 * @postcondition: getArea() == w * old(getHeight())
 *     ✗ VIOLATED! getArea() is now w * w, not w * old(getHeight()).
 * 
 * @invariant: width == height (ALWAYS)
 *     This invariant is STRONGER than Rectangle's (which has none).
 *     To maintain this invariant, Square MUST violate Rectangle's postconditions.
 */
@Override
public void setWidth(int w) {
    this.width = w;
    this.height = w;  // Required to maintain Square's invariant
}                     // BUT violates Rectangle's postcondition!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
 * Invariant Compatibility Analysis
 * 
 * Rectangle allows states:
 *   |  Width  |  Height  |  Valid?  |
 *   |---------|----------|----------|
 *   |    3    |    5     |    ✓     |
 *   |    7    |    2     |    ✓     |
 *   |    4    |    4     |    ✓     |
 *   |   10    |   10     |    ✓     |
 * 
 * Square allows states:
 *   |  Width  |  Height  |  Valid?  |
 *   |---------|----------|----------|
 *   |    3    |    5     |    ✗     |  <- Invalid for Square!
 *   |    7    |    2     |    ✗     |  <- Invalid for Square!
 *   |    4    |    4     |    ✓     |
 *   |   10    |   10     |    ✓     |
 * 
 * Square's valid states are a SUBSET of Rectangle's valid states.
 * This means Square is MORE RESTRICTED than Rectangle.
 * 
 * For LSP to hold, the subclass should support AT LEAST all states
 * that the base class supports. Square supports FEWER states.
 * 
 * This is the INVARIANT TRAP: A subclass with a stronger invariant
 * cannot substitute for a base class with a weaker invariant.
 */
 
// The problem manifests when clients try to use Rectangle's full state space:
 
void clientCode(Rectangle rect) {
    rect.setWidth(10);
    rect.setHeight(5);  // Perfectly valid for Rectangle
    
    // Client expects width=10, height=5
    // But if rect is actually a Square:
    //   - setWidth(10) sets width=10, height=10
    //   - setHeight(5) sets width=5, height=5
    //   - Final state: width=5, height=5
    // 
    // The client's expectations are VIOLATED
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

public class ImmutableRectangle {
    private final int width;
    private final int height;
 
    public ImmutableRectangle(int width, int height) {
        this.width = width;
        this.height = height;
    }
 
    public int getWidth()  { return width; }
    public int getHeight() { return height; }
    public int getArea()   { return width * height; }
    
    // No setters — the object is immutable after construction
    
    // Factory methods to create modified copies
    public ImmutableRectangle withWidth(int newWidth) {
        return new ImmutableRectangle(newWidth, this.height);
    }
    
    public ImmutableRectangle withHeight(int newHeight) {
        return new ImmutableRectangle(this.width, newHeight);
    }
}
 
public class ImmutableSquare extends ImmutableRectangle {
    
    public ImmutableSquare(int side) {
        super(side, side);
    }
    
    // Override factory methods to return squares
    @Override
    public ImmutableRectangle withWidth(int newWidth) {
        return new ImmutableRectangle(newWidth, getHeight());
        // Returns a Rectangle, not a Square — this is correct!
        // Changing one dimension breaks the "squareness"
    }
    
    @Override
    public ImmutableRectangle withHeight(int newHeight) {
        return new ImmutableRectangle(getWidth(), newHeight);
        // Returns a Rectangle, not a Square — also correct!
    }
    
    // Square-specific method
    public ImmutableSquare withSide(int newSide) {
        return new ImmutableSquare(newSide);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

/**
 * History Rule Violation Demonstration
 * 
 * Consider the following sequence of operations on a Rectangle:
 */
 
void demonstrateHistoryViolation() {
    // Valid sequence for Rectangle
    Rectangle rect = new Rectangle(4, 4);  // State: {4, 4}
    rect.setWidth(10);                      // State: {10, 4}
    rect.setHeight(5);                      // State: {10, 5}
    // Final state: width=10, height=5
    
    // Rectangle's "history" includes:
    // {4,4} -> {10,4} -> {10,5}
    // This is a VALID history for Rectangle
    
    // Now apply same sequence to Square:
    Rectangle square = new Square(4);  // State: {4, 4}
    square.setWidth(10);                // State: {10, 10}  <- Different!
    square.setHeight(5);                // State: {5, 5}    <- Different!
    // Final state: width=5, height=5
    
    // Square's "history" is:
    // {4,4} -> {10,10} -> {5,5}
    // 
    // Square CANNOT reach state {10, 5} or {10, 4}
    // These are valid Rectangle states that Square cannot support
    // 
    // The HISTORY RULE is violated because:
    // - Rectangle can reach {10, 4} but Square cannot
    // - Rectangle can reach {10, 5} but Square cannot
    // - The possible "histories" of Square are a proper subset
    //   of the possible histories of Rectangle
}
 
/**
 * For LSP to hold, any history possible for the base type
 * must also be possible for the subtype.
 * 
 * Square violates this because many Rectangle histories
 * are impossible for Square.
 */

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

/**
 * Systematic LSP Verification for Square extends Rectangle
 * 
 * This demonstrates how to formally verify LSP compliance.
 */
public class LSPVerification {
    
    // Test 1: Postcondition Check
    public static boolean postconditionCheck(Rectangle r) {
        int originalHeight = r.getHeight();
        r.setWidth(10);
        
        // Rectangle's postcondition: height unchanged after setWidth
        return r.getHeight() == originalHeight;  // FAILS for Square
    }
    
    // Test 2: Independent Dimension Check
    public static boolean independentDimensionCheck(Rectangle r) {
        r.setWidth(10);
        r.setHeight(20);
        
        // Must be able to set dimensions to different values
        return r.getWidth() == 10 && r.getHeight() == 20;  // FAILS for Square
    }
    
    // Test 3: History Check
    public static boolean historyCheck(Rectangle r) {
        // Can we reach state {10, 5}?
        r.setWidth(10);
        r.setHeight(5);
        
        return r.getWidth() == 10 && r.getHeight() == 5;  // FAILS for Square
    }
    
    // Running with different types:
    public static void main(String[] args) {
        Rectangle rect = new Rectangle(5, 5);
        System.out.println("Rectangle - Postcondition: " + postconditionCheck(rect));       // true
        System.out.println("Rectangle - Independent: " + independentDimensionCheck(rect));   // true
        System.out.println("Rectangle - History: " + historyCheck(rect));                     // true
        
        Rectangle square = new Square(5);
        System.out.println("Square - Postcondition: " + postconditionCheck(square));         // false!
        System.out.println("Square - Independent: " + independentDimensionCheck(square));     // false!
        System.out.println("Square - History: " + historyCheck(square));                       // false!
    }
}