SOLID

In object-oriented computer programming, SOLID is a mnemonic acronym for five design principles intended to make software designs more understandable, flexible, and maintainable. The principles are a subset of many principles promoted by American software engineer and instructor Robert C. Martin.[1][2][3]

This article is about the SOLID principles of object-oriented programming. For the fundamental state of matter, see Solid. For other uses, see Solid (disambiguation).
SOLID
Principles

History

The theory of SOLID principles was introduced by Robert C. Martin in his 2000 paper Design Principles and Design Patterns.[2][4]

The SOLID acronym was introduced later in 2004 or thereabouts by Michael Feathers.[5]

Concepts

Although they apply to any object-oriented design, the SOLID principles can also form a core philosophy for methodologies such as agile development or adaptive software development.[3]

Single-responsibility principle[6]
A class should only have a single responsibility, that is, only changes to one part of the software's specification should be able to affect the specification of the class.
Open–closed principle[7]
"Software entities ... should be open for extension, but closed for modification."
Liskov substitution principle[8]
"Objects in a program should be replaceable with instances of their subtypes without altering the correctness of that program." See also design by contract.
Interface segregation principle[9]
"Many client-specific interfaces are better than one general-purpose interface."[4]
Dependency inversion principle[10]
One should "depend upon abstractions, [not] concretions."[4]

See also

References
  1. Robert C. Martin. "Principles Of OOD". butunclebob.com. Retrieved 2014-07-17.. (Note the reference to "the first five principles", although the acronym is not used in this article.) Dates back to at least 2003.
  2. Robert C. Martin. "Getting a SOLID start". objectmentor.com. Retrieved 2013-08-19.
  3. Sandi Metz (May 2009). "SOLID Object-Oriented Design". Retrieved 2019-08-13. Talk given at the 2009 Gotham Ruby Conference.
  4. Martin, Robert C. (2000). "Design Principles and Design Patterns" (PDF). Archived from the original (PDF) on 2015-09-06.
  5. Martin, Robert (2018). Clean Architecture: A Craftsman's Guide to Software Structure and Design. p. 58. ISBN 9780134494166.
  6. "Single Responsibility Principle" (PDF). objectmentor.com. Archived from the original (PDF) on 2 February 2015.
  7. "Open/Closed Principle" (PDF). objectmentor.com. Archived from the original (PDF) on 5 September 2015.
  8. "Liskov Substitution Principle" (PDF). objectmentor.com. Archived from the original (PDF) on 5 September 2015.
  9. "Interface Segregation Principle" (PDF). objectmentor.com. 1996. Archived from the original (PDF) on 5 September 2015.
  10. "Dependency Inversion Principle" (PDF). objectmentor.com. Archived from the original (PDF) on 5 September 2015.
This article is issued from Wikipedia. The text is licensed under Creative Commons - Attribution - Sharealike. Additional terms may apply for the media files.