Nsryjdtyk

Every class, directly or indirectly, inherits from the Object class.

The Object class, among the others, has the important method, most often overridden: toString.

The question is: doesn't the overriding of this method bring to Liskov Substitution Principle violation with respect to the Object class?

I'll do an example.

public class Main

{

    public static void main(String args)

    {

        Object o = new Object();

        String s = o.toString();

        if (s.indexOf('@') > -1) {

            System.out.println("OK");

        } else {

            System.out.println(":-(");

        }

    }

}



public class MyClass

{

    private int x;



    public string toString()

    {

        return Integer.toString(x);

    }

}

Obviously if I replace new Object() with new MyClass() the behavior of the system changes.

Well, it's a matter of taste. Object has almost no guaranteed properties. So there is no much to violate either.

If you say that returning the class name is such a property that may be violated, then of course, a subclass should not change this. But reading the documentation of Object.toString() turns out that there is no such guarantee:

Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object.

So I see no LSP violation here.

LSP does not say that a subclass must behave exactly the same as the superclass. This would make subclasses entirely useless. It only requires that subclasses meet the specification of the superclass.

The only thing one could mention is that Object enforces a meaningless method toString for every object. A more sophisticated design might have put this into an interface.

I think this design choice is just a compromise, taken over by other languages like .NET as well.

Liskov substitution principle requires only interface compatibility. It does not say anything abound underlying behavior. So for example

public interface Text {

    String value();

}



public class SimpleText implements Text {



    private final String value;



    public SimpleText(String value) {

        this.value = value;

    }



    @Override

    public String value() {

        return this.value;

    }

}



public class NumberText implements Text {



    private final Number number;



    public NumberText(Number number) {

        this.number = number;

    }



    @Override

    public String value() {

        return String.format("%.3f", this.number.doubleValue());

    }

}

You do not care about details of implementation, so you can exchange them this way:

//We care only about value() method, not it's specific implementation

Text text = new SimpleText("text");

text.value();

text = new NumberText(44);

text.value();