向子类添加公共方法是否违反了LSP（Liskov替换原则）？

Question

If I add public method to subclass and a client program calls added method, client programs can't use parent object instead of subclass.

import unittest

class BaseClass(object):

    def doSomething(self):
        pass


class SubClass(BaseClass):

    def doStuff(self):
        pass

class Client(object):

    def __init__(self, obj):
        self.obj = obj

    def do(self):
        self.obj.doStuff()

class LSPTestCase(unittest.TestCase):

    def test_call_subclass_method(self):
        client = Client(SubClass())
        client.do()

    def test_call_baseclass_method(self):
        client = Client(BaseClass())
        with self.assertRaises(AttributeError):
            client.do()

if __name__ == '__main__':
    unittest.main()

This case violates LSP?

Answer 1

No as long as all the methods inherrited from the parent class follow the same contract as the parent then LSP is preserved.

the whole point of LSP is to be able to pass around a subclass as the parent class without any problems. It says nothing about not being able to downcast for additional functionality.

Answer 2

Adding a method to a subclass does not violate LSP. However, it does violate if you invoke that method by downcasting from a parent class.

Robert C. Martin states right in the beginning of his LSP / SOLID paper that:

select a function based upon the type of an object

(...) is an example of a simple violation of the Liskov Substitution Principle.

Generally, if you end up in situations where you need to downcast or use the instanceof operator, it's better to revisit the use of inheritance in favor of other approaches like composition.