I was discussing the "Double Dispatch" stuff with my brother, and I decided to dig into the OO Principles. So, while browsing the wiki I reached to SOLID. I am not an Academic Computer person, but it is pretty interesting; also a little lengthier for a non comp-sci person. I though I can put it down in some Simple words (may not be technically VERY correct; but these are my understandings)
Single Responsibility :=> Introduced by Robert C Martin and based on Principle of Cohesion. In simple words Martin defined 'Responsibility' as "Reason to Change"; any Class can only have ONE reason to change after designing. [wiki has a good example].
Open/Closed Principle (Polymorphic) :=> Originally stated as "software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification". Now this is popularly known/referred as "Abstract Interfaces". We create an Abstract Interface and 'Close' it for modification (sort of standardizing the project; and standards don't change). Using this Interface, multiple implementations can be created and 'Polymorphically' substituted for each other.
Liskov Substitution :=> Originally stated as "if S is a subtype of T, then objects of type T may be replaced with objects of type S", which today we know as "Polymorphic Behavior". But the principle does not supports strongly typed systems. The Liskov Substitution Principle defines Strong Behavioral Sub-typing which leads to a notion of substitutability for mutable objects.
Interface Segregation :=> This is very similar to Single Responsibility principle, which helps for Clean Development and easy to Modify Software and also known as Loose Coupling.
Dependancy Inversion :=> The principle states: [A] High-level modules should not depend on low-level modules. Both should depend on abstractions. [B] Abstractions should not depend upon details. Details should depend upon abstractions.
Finally, here is one of the Best Resources Available.
