SOLID பராமரிக்கக்கூடிய, நீட்டிக்கக்கூடிய மற்றும் நெகிழ்வான அமைப்புகளை உருவாக்க பயன்படும் மென்பொருள் வடிவமைப்பில் உள்ள அடிப்படைக் கொள்கைகளின் தொகுப்பைக் குறிக்கிறது. SOLID இந்த ஐந்து கொள்கைகளின் ஆரம்ப எழுத்துக்களால் உருவான சுருக்கம்:
எஸ்- Single Responsibility Principle
ஒரு வகுப்பு அல்லது தொகுதிக்கு ஒரே ஒரு பொறுப்பு மட்டுமே இருக்க வேண்டும். இது மற்ற செயல்பாடுகளை பாதிக்காமல் குறியீட்டை எளிதாக பராமரிக்கவும் மாற்றவும் உதவுகிறது.
ஓ- Open/Closed Principle
நீட்டிப்புக்காக குறியீடு திறந்திருக்க வேண்டும்(புதிய அம்சங்களைச் சேர்ப்பது) ஆனால் மாற்றத்திற்காக மூடப்பட்டிருக்க வேண்டும்(ஏற்கனவே இருக்கும் குறியீட்டை மாற்றவில்லை). இது ஏற்கனவே உள்ள குறியீட்டை மாற்றாமல் புதிய அம்சங்களைச் சேர்க்க பரம்பரை, இடைமுகங்கள் அல்லது பிற நீட்டிப்பு வழிமுறைகளைப் பயன்படுத்துவதை ஊக்குவிக்கிறது.
எல்- Liskov Substitution Principle
துணைப்பிரிவின் பொருள்கள், நிரலின் சரியான தன்மையைப் பாதிக்காமல், பெற்றோர் வகுப்பின் பொருள்களுக்குப் பதிலாக இருக்க வேண்டும். இது பரம்பரை பாதுகாப்பாகவும் சரியாகவும் செயல்படுத்தப்படுவதை உறுதி செய்கிறது.
நான்- Interface Segregation Principle
பல முறைகளைக் கொண்ட பெரிய இடைமுகத்தைக் காட்டிலும் சிறிய மற்றும் குறிப்பிட்ட இடைமுகங்களைக் கொண்டிருப்பது நல்லது. வகுப்புகள் தேவையற்ற முறைகளைச் செயல்படுத்த நிர்பந்திக்கப்படுவதைத் தவிர்க்க இது உதவுகிறது.
D- Dependency Inversion Principle
உயர்-நிலை தொகுதிகள் குறைந்த-நிலை தொகுதிகளை சார்ந்து இருக்கக்கூடாது. இரண்டும் சுருக்கங்களைச் சார்ந்திருக்க வேண்டும். தொகுதிகளுக்கு இடையே இறுக்கமான இணைப்பைக் குறைப்பதற்கும், சோதனை மற்றும் நீட்டிப்பதற்கும் கணினியை எளிதாக்குவதற்கு சார்பு ஊசியைப் பயன்படுத்துவதை இந்தக் கொள்கை ஊக்குவிக்கிறது.
SOLID கொள்கைகள் குறியீட்டு கட்டமைப்பை மேம்படுத்துகிறது, மட்டுப்படுத்தலை ஊக்குவிக்கிறது மற்றும் மாற்றங்களுடன் தொடர்புடைய ஆபத்தை குறைக்கிறது. இந்த கொள்கைகள் பல்வேறு நிரலாக்க மொழிகள் மற்றும் மேம்பாட்டு சூழல்களில் பயன்படுத்தப்படலாம்.