බොහෝ විට මට SOLID මූලධර්ම ගැන අසා නැති සංවර්ධකයින් හමුවෙයි (අපි . — Transl.) හෝ object-oriented programming (OOP), හෝ ඒවා ගැන අසා ඇත, නමුත් ඒවා ප්‍රායෝගිකව භාවිතා නොකරන්න. මෙම ලිපිය සංවර්ධකයාට ඔහුගේ දෛනික වැඩ කටයුතු සඳහා උපකාර වන OOP මූලධර්මවල ප්‍රතිලාභ විස්තර කරයි. ඔවුන්ගෙන් සමහරක් හොඳින් දන්නා අතර අනෙක් ඒවා එතරම් නොවේ, එබැවින් ලිපිය ආරම්භකයින් සහ පළපුරුදු වැඩසටහන්කරුවන් සඳහා ප්රයෝජනවත් වනු ඇත.
අපි ඔබට මතක් කරමු: සියලුම Habr පාඨකයන් සඳහා - Habr ප්‍රවර්ධන කේතය භාවිතයෙන් ඕනෑම Skillbox පාඨමාලාවකට ලියාපදිංචි වන විට රුබල් 10ක වට්ටමක්.
Skillbox නිර්දේශ කරයි: අධ්‍යාපනික මාර්ගගත පාඨමාලාව .
වියළි (නැවත නැවත නොකියන්න)
තරමක් සරල මූලධර්මයක්, එහි සාරය නමෙන් පැහැදිලි වේ: "ඔබම නැවත නොකියන්න." ක්‍රමලේඛකයෙකු සඳහා, මෙයින් අදහස් කරන්නේ අනුපිටපත් කේතය වළක්වා ගැනීමේ අවශ්‍යතාවය මෙන්ම ඔවුන්ගේ කාර්යයේදී වියුක්තය භාවිතා කිරීමේ අවස්ථාවයි.
කේතයේ පුනරාවර්තන කොටස් දෙකක් තිබේ නම්, ඒවා එක් ක්රමයකට ඒකාබද්ධ කළ යුතුය. දෘඪ කේත අගයක් එක් වරකට වඩා භාවිතා කරන්නේ නම්, එය පොදු නියතයක් බවට පරිවර්තනය කිරීම වටී.
OOP හි ප්‍රධාන ඉලක්කය වන කේතය සරල කිරීමට සහ නඩත්තු කිරීම පහසු කිරීමට මෙය අවශ්ය වේ. එකම කේතය OrderId සහ SSN යන දෙකම සමඟ සත්‍යාපනය සමත් නොවන බැවින්, ඔබ සංගමය අධික ලෙස භාවිත නොකළ යුතුය.
සංවෘත වෙනස්කම්
බොහෝ සමාගම්වල මෘදුකාංග නිෂ්පාදන නිරන්තරයෙන් පරිණාමය වෙමින් පවතී. මෙයින් අදහස් කරන්නේ කේතයේ වෙනස්කම් සිදු කළ යුතු බවයි, එය සහාය විය යුතුය. කැප්සියුලේෂන් භාවිතා කිරීමෙන් ඔබට ඔබේ ජීවිතය පහසු කර ගත හැකිය. ඔබගේ පවතින කේත පදනම වඩාත් කාර්යක්ෂමව පරීක්ෂා කිරීමට සහ නඩත්තු කිරීමට මෙය ඔබට ඉඩ සලසයි. .
ඔබ ජාවා වලින් ලියන්නේ නම්, එසේ නම් .
විවෘත / සංවෘත මූලධර්මය
පහත ප්‍රකාශය කියවීමෙන් මෙම මූලධර්මය පහසුවෙන් මතක තබා ගත හැක: "මෘදුකාංග ආයතන (පන්ති, මොඩියුල, ශ්‍රිත ආදිය) දිගුව සඳහා විවෘතව තිබිය යුතු නමුත් වෙනස් කිරීම සඳහා වසා තිබිය යුතුය." ප්‍රායෝගිකව, මෙයින් අදහස් කරන්නේ මූලාශ්‍ර කේතය වෙනස් නොකර ඔවුන්ගේ හැසිරීම වෙනස් කිරීමට ඉඩ දිය හැකි බවයි.
මූල කේතයේ වෙනස්කම් සඳහා කේත සංශෝධනය, ඒකක පරීක්ෂාව සහ වෙනත් ක්‍රියා පටිපාටි අවශ්ය වූ විට මූලධර්මය වැදගත් වේ. විවෘත/සංවෘත මූලධර්මය අනුගමනය කරන කේතය දිගු කළ විට වෙනස් නොවේ, එබැවින් එය සමඟ ගැටලු ඇත්තේ ඉතා අඩුය.
මෙම මූලධර්මය උල්ලංඝනය කරන කේතයේ උදාහරණයක් මෙන්න.
ඔබට එහි යමක් වෙනස් කිරීමට අවශ්ය නම්, එය බොහෝ කාලයක් ගතවනු ඇත, මන්ද අපේක්ෂිත කොටස සමඟ සම්බන්ධයක් ඇති කේතයේ සියලුම කොටස් වෙනස් කිරීමට සිදුවනු ඇත.
මාර්ගය වන විට, විවෘතභාවය-වසා දැමීම SOLID හි මූලධර්මවලින් එකකි.
තනි වගකීම් මූලධර්මය (SRP)
SOLID කට්ටලයෙන් තවත් මූලධර්මයක්. එහි සඳහන් වන්නේ "පංතියේ වෙනසක් ඇති කරන එක් හේතුවක් පමණි." පන්තිය විසඳන්නේ එක් ගැටලුවක් පමණි. එයට ක්රම කිහිපයක් තිබිය හැකි නමුත් ඒ සෑම එකක්ම භාවිතා කරන්නේ පොදු ගැටළුවක් විසඳීමට පමණි. සියලුම ක්රම සහ ගුණාංග මෙය පමණක් සේවය කළ යුතුය.
මෙම මූලධර්මයේ වටිනාකම එය තනි මෘදුකාංග සංරචකය සහ කේතය අතර සම්බන්ධ කිරීම ලිහිල් කරයි. ඔබ class එකකට ක්‍රියාකාරීත්වය එකකට වඩා එකතු කළහොත්, එය ශ්‍රිත දෙක අතර සම්බන්ධතාවයක් හඳුන්වා දෙයි. මේ අනුව, ඔබ ඒවායින් එකක් වෙනස් කළහොත්, පළමු එකට සම්බන්ධ වූ දෙවැන්න විනාශ කිරීමට ඉහළ සම්භාවිතාවක් ඇත. තවද මෙයින් අදහස් කරන්නේ සියලුම ගැටළු කල්තියා හඳුනා ගැනීම සඳහා පරීක්ෂණ චක්‍ර වැඩි කිරීමයි.
යැපුම් ප්‍රතිලෝම මූලධර්මය (DIP)
ඉහත දැක්වෙන්නේ AppManager EventLogWriter මත රඳා පවතින කේත උදාහරණයකි, එය AppManager සමඟ සමීපව සම්බන්ධ වේ. ඔබට දැනුම්දීමක් පෙන්වීමට වෙනස් ක්‍රමයක් අවශ්ය නම්, එය තල්ලු කිරීම, SMS හෝ ඊමේල් වේවා, ඔබ AppManager පන්තිය වෙනස් කළ යුතුය.
DIP භාවිතයෙන් ගැටළුව විසඳා ගත හැකිය. එබැවින්, AppManager වෙනුවට, අපි EventLogWriter එකක් ඉල්ලා සිටිමු, එය රාමුව භාවිතයෙන් ඇතුල් කරනු ලැබේ.
DIP මඟින් පරායත්ත මොඩියුලය වෙනස් කිරීමෙන් තනි මොඩියුල වෙනත් අය සමඟ පහසුවෙන් ප්‍රතිස්ථාපනය කිරීමට හැකි වේ. මෙමගින් එක් මොඩියුලයක් අනෙක් ඒවාට බලපෑම් නොකර වෙනස් කිරීමට හැකි වේ.
උරුමය වෙනුවට සංයුතිය
කේතය නැවත භාවිතා කිරීමට ප්‍රධාන ක්රම දෙකක් තිබේ: උරුමය සහ සංයුතිය, ඒ දෙකටම තමන්ගේම වාසි සහ අවාසි ඇත. සාමාන්යයෙන් දෙවැන්න වඩාත් නම්යශීලී බැවින් වඩාත් කැමති වේ.
සංයුතිය මඟින් පන්තියක ගුණාංග සැකසීමෙන් ධාවන වේලාවේදී එහි හැසිරීම වෙනස් කිරීමට ඔබට හැකියාව ලැබේ. අතුරුමුහුණත් ක්රියාත්මක කිරීමේදී, බහුරූපතාව භාවිතා කරනු ලැබේ, එය වඩාත් නම්යශීලී ක්රියාත්මක කිරීමක් ලබා දෙයි.
Joshua Bloch විසින් Effective Java පවා උරුමයට වඩා සංයුතිය තෝරා ගැනීමට උපදෙස් දෙයි.
බාබරා ලිස්කොව් ආදේශන මූලධර්මය (LSP)
SOLID මෙවලම් කට්ටලයේ තවත් මූලධර්මයක්. එහි සඳහන් වන්නේ සුපිරි වර්ගය සඳහා උප වර්ග ආදේශ කළ යුතු බවයි. එනම්, සුපිරි පන්තියක් සමඟ වැඩ කරන ක්රම සහ කාර්යයන් එහි උප පංති සමඟ ගැටළු නොමැතිව වැඩ කිරීමට හැකි විය යුතුය.
LSP තනි වගකීම් මූලධර්මය සහ හවුල් වගකීම් මූලධර්මය යන දෙකටම සම්බන්ධ වේ. පන්තියක් උප පංතියකට වඩා වැඩි ක්‍රියාකාරීත්වයක් ලබා දෙන්නේ නම්, මෙම මූලධර්මය උල්ලංඝනය කරමින් දෙවැන්න සමහර ක්‍රියාකාරීත්වයට සහාය නොදක්වයි.
මෙන්න LSP වලට පටහැනි කේතයක්.
ප්රදේශය (සෘජුකෝණාස්රය r) ක්රමය සෘජුකෝණාස්රයක ප්රදේශය ගණනය කරයි. Square මෙහි සෘජුකෝණාස්‍රයක් නොවන නිසා Square ක්රියාත්මක කිරීමෙන් පසු වැඩසටහන බිඳ වැටෙනු ඇත. LSP මූලධර්මයට අනුව, මූලික පන්ති සඳහා යොමු භාවිතා කරන ශ්‍රිතවලට අමතර උපදෙස් නොමැතිව ව්‍යුත්පන්න පන්තිවල වස්තූන් භාවිතා කිරීමට හැකි විය යුතුය.
උප වර්ගයක නිශ්චිත නිර්වචනයක් වන මෙම මූලධර්මය බාබරා ලිස්කොව් විසින් 1987 සම්මන්ත්‍රණ ප්‍රධාන දේශනයකදී "දත්ත වියුක්ත කිරීම සහ ධූරාවලිය" යන මාතෘකාව යටතේ යෝජනා කරන ලදී.
අතුරු මුහුණත බෙදීමේ මූලධර්මය (ISP)
තවත් SOLID මූලධර්මයක්. එය අනුව, භාවිතා නොකරන අතුරු මුහුණතක් ක්රියාත්මක නොකළ යුතුය. මෙම මූලධර්මය අනුගමනය කිරීම මඟින් මෙහෙයුම් තර්කයට වෙනස් කිරීම් සිදු කරන විට පද්ධතිය නම්‍යශීලීව සහ ප්‍රතිනිර්මාණය කිරීමට සුදුසුව සිටීමට උපකාරී වේ.
බොහෝ විට, මෙම තත්වය සිදුවන්නේ අතුරු මුහුණත එකවර කාර්යයන් කිහිපයක් අඩංගු වන අතර, සේවාදායකයාට අවශ්ය වන්නේ ඒවායින් එකක් පමණි.
අතුරු මුහුණතක් ලිවීම අපහසු කාර්යයක් වන බැවින්, කිසිවක් නොකැඩී වැඩ අවසන් වූ පසු එය වෙනස් කිරීම අභියෝගයක් වනු ඇත.
ජාවා හි ISP මූලධර්මයේ වාසිය නම් සියලුම ක්රම ප්‍රථමයෙන් ක්රියාත්මක කළ යුතු අතර පසුව පමණක් ඒවා පන්ති මගින් භාවිතා කළ හැකිය. එබැවින්, මූලධර්මය ක්රම ගණන අඩු කිරීමට හැකි වේ.
ක්රියාත්මක කිරීම නොව අතුරු මුහුණත සඳහා ක්‍රමලේඛනය කිරීම
මෙහි සෑම දෙයක්ම මාතෘකාවෙන් පැහැදිලි වේ. මෙම මූලධර්මය යෙදීමෙන් අතුරු මුහුණතේ ඕනෑම නව ක්රියාත්මක කිරීමක් සමඟ ක්‍රියා කළ හැකි නම්යශීලී කේතයක් නිර්මාණය කිරීමට මග පාදයි.
ඔබ විචල්‍යයන්, ප්‍රතිලාභ වර්ග, හෝ ක්රම තර්ක වර්ගය සඳහා අතුරු මුහුණත් වර්ගය භාවිතා කළ යුතුය. උදාහරණයක් වන්නේ SubClass වෙනුවට SuperClass භාවිතා කිරීමයි.
එනම්:
ලැයිස්තු අංක= getNumbers();
නමුත් නොවේ:
ArrayList numbers = getNumbers();
ඉහත සාකච්ඡා කළ දේ ප්‍රායෝගිකව ක්රියාත්මක කිරීමකි.
නියෝජිතයින්ගේ මූලධර්මය
පොදු උදාහරණයක් වන්නේ ජාවා හි සමාන() සහ hashCode() ක්රම වේ. වස්තු දෙකක් සංසන්දනය කිරීමට අවශ්ය වූ විට, මෙම ක්‍රියාව සේවාදායකයා වෙනුවට අනුරූප පන්තියට පවරනු ලැබේ.
මූලධර්මයේ වාසිය නම් කේතයේ අනුපිටපතක් නොමැති අතර හැසිරීම වෙනස් කිරීම සාපේක්ෂව සරල ය. එය සිදුවීම් නියෝජිතයින්ට ද අදාළ වේ.
මෙම සියලු මූලධර්ම ඔබට ඉහළ එකමුතුකම සහ අඩු සම්බන්ධ කිරීම සමඟ වඩාත් නම්යශීලී, ලස්සන සහ විශ්වාසදායක කේතයක් ලිවීමට ඉඩ සලසයි. ඇත්ත වශයෙන්ම, න්‍යාය හොඳයි, නමුත් සංවර්ධකයෙකුට ඇත්ත වශයෙන්ම ලබාගත් දැනුම භාවිතා කිරීමට, පුහුණුව අවශ්ය වේ. ඔබ OOP මූලධර්ම ප්‍රගුණ කළ පසු, ඔබේ මීළඟ පියවර වනුයේ පොදු මෘදුකාංග සංවර්ධන ගැටලු විසඳීමට සැලසුම් රටා ඉගෙන ගැනීමයි.
Skillbox නිර්දේශ කරයි:
- ප්රායෝගික පාඨමාලාව .
- මාර්ගගත පාඨමාලාවට අයදුම් කර ඇත .
- වසර දෙකක ප්රායෝගික පාඨමාලාව .
මූලාශ්රය: www.habr.com