Understanding the SOLID Principles

Solid is an acronym that stands for five principles of object-oriented programming and design.

S-Single Responsibility Principle

O-Open/Closed Principle

L-Liskov Substitution Principle

I- Interface Segregation Principle

D-Dependency Inversion Principle

These principles help to avoid dependencies between the classes.

Now talking a little bit more of these principles we understand the following:

Single Responsibility Principle- This principle states that one class should only have one responsibility so the changes in that class do not end up affecting unrelated critical features on the system. This happens from a single action to a set of processes. You can take a view that a single responsibility refers to a group of related business processes. The stamina and tolerance determine how far you go

Open/closed Principle- This principle talks about that classes should be open for extension but closed for modification, this means that adding new behavior instead of changing the base of a class you should create new classes that inherit from this class and add the behavior there. This helps to avoid errors in child classes

Liskov Substitution Principle- You can pass a new class to an existing function that has been written to work with the base class, and the function will perform its work just as if you had passed an instance of the base class. This principle intended to keep alive and well the working relationship between classes and functions. You should forbid modification of a behavior through the mechanism of inherence.

Interface Segregation Principle- This principle tell us to divide and conquer. Instead of writing a big interface, divide the interface members and put them together so the class would not be loaded with responsibilities we won´t use.

Dependency Inversion- This principle basically tell us to write code that refers to abstract classes and interfaces instead to actual classes