SOLID principles
Five principles that make object-oriented designs easier to understand, change and maintain. The text is adapted from the training-algorithms repositories' README.
S Single Responsibility principle
“There should never be more than one reason for a class to change.”
- A class should only have one reason to change
- Separation of concerns
- Different classes handle different, independent tasks
- addNote(note)
- removeNote(pos)
- saveToFile(name)
- loadFromFile(name)
- saveToFile(diary, name)
- loadFromFile(name)
Two reasons to change: note rules and file storage live in one class.
The repository splits a Diary (manages notes) from a PersistenceManager (saves and loads them):
class Diary:
def __init__(self) -> None:
self.notes = []
self.count = 0
def add_note(self, note: str) -> None:
"""Adds a new note to the diary."""
self.count += 1
self.notes.append(f"{self.count}: {note}")
def remove_note(self, pos: int) -> None: ...
def __str__(self) -> str:
return "\n".join(self.notes)
class PersistenceManager:
@staticmethod
def save_to_file(diary: Diary, filename: str) -> None: ...
@staticmethod
def load_from_file(filename: str) -> Diary: ...O Open–Closed principle
“Software entities should be open for extension, but closed for modification.”
- Add behaviour by adding new code (subclasses, strategies), not by editing tested code
A code example for this principle is coming soon.
L Liskov Substitution principle
“Functions that use pointers or references to base classes must be able to use objects of derived classes without knowing it.”
- You should be able to substitute a base type with a subtype
A code example for this principle is coming soon.
I Interface Segregation principle
“Clients should not be forced to depend upon interfaces that they do not use.”
- Don't put too much into an interface; split it into separate interfaces
- YAGNI: You Aren't Gonna Need It
A code example for this principle is coming soon.
D Dependency Inversion principle
“Depend upon abstractions, not concretions.”
- High-level modules should not depend on low-level ones; both use abstractions
A code example for this principle is coming soon.
Saved in this browser only. Part of Clean code foundations (0/5).