SOLID principles

Object oriented has some principles that when you follow them the non-functional attributes of your codes will be enhanced. SOLID is an acronym for 5 principles what introduced by Robert C Martin and acronym was create by Michael Feathers.

• Single Responsibility Principle : Every class should have just One responsibility and encapsulate its responsibility entirely. The Most important reason of this principle is that there must be just one reason for changing a class. For example when you want to read a config file for database connection information and connect to database you must have two separate class, First for config file reading and the other for connection to database.

• Open Close Principle: Every class should be open for extending and closed modification. When you write a class and you are sure then new features and enhancements must be added with extending class not with modification source code. So your code must be extendable. In the other word just modify your code for errors, new features and enhancements need new class that extends current class.

• Liskov Substitution Principle: If S is a subtype of  T, then objects of type T may be replaced with objects of type S without altering any part of your code.

• Interface Segregation Principle: No client should be force to depend on methods it does not use. ISP means your interfaces must be small and specific for a goal.

• Dependency Inversion Principle: High level modules should not depend on low-level modules. Both should depend on abstractions. Abstractions should not depend upon details. Details should depend upon abstractions. When you are designing an application it is a bad idea that you create dependency between high level and low modules, instead of this model of design, try to design dependencies with specifications then your high level modules just depends on your specification and you can substitute your modules implementations very easy. There are many solutions for Dependency Inversion, Plugin, Service Locator and Dependency Injection are some these patterns.

 

I want to start to explain some of important design patterns in my next posts and it is one the reasons that i explained SOLID principles. There are some other principles you may like to know as (YAGNI , GRASP , KISS , … )