చాలా తరచుగా నేను SOLID సూత్రాల గురించి వినని డెవలపర్‌లను కలుస్తాను (మేము . — Transl.) లేదా ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP), లేదా వాటి గురించి విన్నాను, కానీ వాటిని ఆచరణలో ఉపయోగించవద్దు. డెవలపర్‌కి తన రోజువారీ పనిలో సహాయపడే OOP సూత్రాల ప్రయోజనాలను ఈ కథనం వివరిస్తుంది. వాటిలో కొన్ని బాగా తెలిసినవి, మరికొన్ని అంతగా లేవు, కాబట్టి వ్యాసం ప్రారంభ మరియు అనుభవజ్ఞులైన ప్రోగ్రామర్లకు ఉపయోగకరంగా ఉంటుంది.
మేము గుర్తు చేస్తున్నాము: Habr పాఠకులందరికీ - Habr ప్రోమో కోడ్‌ని ఉపయోగించి ఏదైనా Skillbox కోర్సులో నమోదు చేసుకున్నప్పుడు 10 రూబుల్ తగ్గింపు.
Skillbox సిఫార్సు చేస్తోంది: ఎడ్యుకేషనల్ ఆన్‌లైన్ కోర్సు .
పొడి (మీరే పునరావృతం చేయవద్దు)
చాలా సరళమైన సూత్రం, దీని సారాంశం పేరు నుండి స్పష్టంగా ఉంది: "మీరే పునరావృతం చేయవద్దు." ప్రోగ్రామర్ కోసం, దీని అర్థం నకిలీ కోడ్‌ను నివారించాల్సిన అవసరం, అలాగే వారి పనిలో సంగ్రహణను ఉపయోగించుకునే అవకాశం.
కోడ్‌లో రెండు పునరావృత విభాగాలు ఉంటే, వాటిని ఒక పద్ధతిలో కలపాలి. హార్డ్‌కోడ్ చేయబడిన విలువ ఒకటి కంటే ఎక్కువసార్లు ఉపయోగించబడితే, దానిని పబ్లిక్ స్థిరాంకంగా మార్చడం విలువ.
కోడ్‌ను సులభతరం చేయడానికి మరియు నిర్వహించడాన్ని సులభతరం చేయడానికి ఇది అవసరం, ఇది OOP యొక్క ప్రధాన లక్ష్యం. OrderId మరియు SSN రెండింటితో ఒకే కోడ్ ధృవీకరణను పాస్ చేయదు కాబట్టి మీరు యూనియన్‌ను కూడా అతిగా ఉపయోగించకూడదు.
ఎన్‌క్యాప్సులేటింగ్ మార్పులు
చాలా కంపెనీల సాఫ్ట్‌వేర్ ఉత్పత్తులు నిరంతరం అభివృద్ధి చెందుతున్నాయి. దీనర్థం కోడ్‌లో మార్పులు చేయవలసి ఉంటుంది, దానికి మద్దతు ఇవ్వాలి. ఎన్‌క్యాప్సులేషన్‌ని ఉపయోగించడం ద్వారా మీరు మీ జీవితాన్ని సులభతరం చేయవచ్చు. ఇది మీ ప్రస్తుత కోడ్ బేస్‌ను మరింత సమర్థవంతంగా పరీక్షించడానికి మరియు నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది. .
మీరు జావాలో వ్రాస్తే, అప్పుడు .
ఓపెన్/క్లోజ్డ్ సూత్రం
కింది స్టేట్‌మెంట్‌ను చదవడం ద్వారా ఈ సూత్రాన్ని సులభంగా గుర్తుంచుకోవచ్చు: “సాఫ్ట్‌వేర్ ఎంటిటీలు (క్లాస్‌లు, మాడ్యూల్స్, ఫంక్షన్‌లు మొదలైనవి) పొడిగింపు కోసం తెరవబడి ఉండాలి, కానీ సవరణ కోసం మూసివేయబడతాయి.” ఆచరణలో, సోర్స్ కోడ్‌ను మార్చకుండానే వారు తమ ప్రవర్తనను మార్చుకోవచ్చని దీని అర్థం.
సోర్స్ కోడ్‌లో మార్పులకు కోడ్ రివిజన్, యూనిట్ టెస్టింగ్ మరియు ఇతర విధానాలు అవసరమైనప్పుడు సూత్రం ముఖ్యం. ఓపెన్/క్లోజ్డ్ సూత్రాన్ని అనుసరించే కోడ్ పొడిగించినప్పుడు మారదు, కాబట్టి దానితో చాలా తక్కువ సమస్యలు ఉన్నాయి.
ఈ సూత్రాన్ని ఉల్లంఘించే కోడ్ యొక్క ఉదాహరణ ఇక్కడ ఉంది.
మీరు దానిలో ఏదైనా మార్చాల్సిన అవసరం ఉంటే, అది చాలా సమయం పడుతుంది, ఎందుకంటే కోరుకున్న ఫ్రాగ్మెంట్తో కనెక్షన్ ఉన్న కోడ్ యొక్క అన్ని విభాగాలు మార్చవలసి ఉంటుంది.
మార్గం ద్వారా, ఓపెన్‌నెస్-క్లోజ్‌నెస్ అనేది SOLID సూత్రాలలో ఒకటి.
సింగిల్ రెస్పాన్సిబిలిటీ ప్రిన్సిపల్ (SRP)
SOLID సెట్ నుండి మరొక సూత్రం. ఇది "తరగతిలో మార్పుకు కారణమయ్యే ఒక కారణం మాత్రమే ఉంది" అని పేర్కొంది. తరగతి ఒక సమస్యను మాత్రమే పరిష్కరిస్తుంది. దీనికి అనేక పద్ధతులు ఉండవచ్చు, కానీ వాటిలో ప్రతి ఒక్కటి సాధారణ సమస్యను పరిష్కరించడానికి మాత్రమే ఉపయోగించబడుతుంది. అన్ని పద్ధతులు మరియు లక్షణాలు దీనికి మాత్రమే ఉపయోగపడాలి.
ఈ సూత్రం యొక్క విలువ ఏమిటంటే ఇది వ్యక్తిగత సాఫ్ట్‌వేర్ కాంపోనెంట్ మరియు కోడ్ మధ్య కలయికను వదులుతుంది. మీరు తరగతికి ఒకటి కంటే ఎక్కువ కార్యాచరణలను జోడిస్తే, అది రెండు ఫంక్షన్‌ల మధ్య సంబంధాన్ని పరిచయం చేస్తుంది. అందువలన, మీరు వాటిలో ఒకదానిని మార్చినట్లయితే, మొదటిదానితో అనుసంధానించబడిన రెండవదాన్ని నాశనం చేసే అధిక అవకాశం ఉంది. మరియు దీని అర్థం అన్ని సమస్యలను ముందుగానే గుర్తించడానికి పరీక్షా చక్రాలను పెంచడం.
డిపెండెన్సీ ఇన్వర్షన్ ప్రిన్సిపల్ (డిఐపి)
AppManager EventLogWriterపై ఆధారపడి ఉండే కోడ్ ఉదాహరణ పైన ఉంది, ఇది AppManagerతో సన్నిహితంగా జతచేయబడుతుంది. నోటిఫికేషన్‌ను చూపడానికి మీకు వేరే మార్గం అవసరమైతే, అది పుష్, SMS లేదా ఇమెయిల్ కావచ్చు, మీరు AppManager తరగతిని మార్చాలి.
డిఐపిని ఉపయోగించి సమస్యను పరిష్కరించవచ్చు. కాబట్టి, AppManagerకి బదులుగా, మేము EventLogWriterని అభ్యర్థిస్తాము, ఇది ఫ్రేమ్‌వర్క్‌ని ఉపయోగించి నమోదు చేయబడుతుంది.
డిపెండెన్సీ మాడ్యూల్‌ను మార్చడం ద్వారా వ్యక్తిగత మాడ్యూళ్లను ఇతరులతో సులభంగా భర్తీ చేయడం DIP సాధ్యం చేస్తుంది. ఇది ఒక మాడ్యూల్‌ను ఇతరులను ప్రభావితం చేయకుండా మార్చడం సాధ్యపడుతుంది.
వారసత్వానికి బదులుగా కూర్పు
కోడ్‌ని మళ్లీ ఉపయోగించుకోవడానికి రెండు ప్రధాన మార్గాలు ఉన్నాయి: వారసత్వం మరియు కూర్పు, రెండూ వాటి స్వంత ప్రయోజనాలు మరియు అప్రయోజనాలు కలిగి ఉంటాయి. సాధారణంగా రెండవదానికి ప్రాధాన్యత ఇవ్వబడుతుంది ఎందుకంటే ఇది మరింత సరళమైనది.
రన్‌టైమ్‌లో తరగతి లక్షణాలను సెట్ చేయడం ద్వారా దాని ప్రవర్తనను మార్చగల సామర్థ్యాన్ని కంపోజిషన్ మీకు అందిస్తుంది. ఇంటర్‌ఫేస్‌లను అమలు చేస్తున్నప్పుడు, పాలిమార్ఫిజం ఉపయోగించబడుతుంది, ఇది మరింత సౌకర్యవంతమైన అమలును ఇస్తుంది.
జాషువా బ్లాచ్ చేత ఎఫెక్టివ్ జావా కూడా వారసత్వం కంటే కూర్పును ఎంచుకోవాలని సలహా ఇస్తుంది.
బార్బరా లిస్కోవ్ ప్రత్యామ్నాయ సూత్రం (LSP)
SOLID టూల్‌కిట్ నుండి మరొక సూత్రం. సూపర్ టైప్‌కు సబ్‌టైప్‌లు తప్పనిసరిగా ప్రత్యామ్నాయంగా ఉండాలని ఇది పేర్కొంది. అంటే, సూపర్‌క్లాస్‌తో పనిచేసే పద్ధతులు మరియు విధులు దాని సబ్‌క్లాస్‌లతో సమస్యలు లేకుండా పని చేయగలగాలి.
LSP ఒకే బాధ్యత సూత్రం మరియు భాగస్వామ్య బాధ్యత సూత్రం రెండింటితో అనుబంధించబడింది. ఒక తరగతి సబ్‌క్లాస్ కంటే ఎక్కువ కార్యాచరణను అందిస్తే, రెండోది ఈ సూత్రాన్ని ఉల్లంఘిస్తూ కొన్ని కార్యాచరణలకు మద్దతు ఇవ్వదు.
LSPకి విరుద్ధంగా ఉండే కోడ్ ముక్క ఇక్కడ ఉంది.
ప్రాంతం (దీర్ఘచతురస్రం r) పద్ధతి దీర్ఘచతురస్రం యొక్క వైశాల్యాన్ని గణిస్తుంది. స్క్వేర్ ఇక్కడ దీర్ఘచతురస్రం కానందున స్క్వేర్‌ని అమలు చేసిన తర్వాత ప్రోగ్రామ్ క్రాష్ అవుతుంది. LSP సూత్రం ప్రకారం, ప్రాథమిక తరగతులకు సూచనలను ఉపయోగించే విధులు అదనపు సూచనలు లేకుండా ఉత్పన్నమైన తరగతుల వస్తువులను ఉపయోగించగలగాలి.
సబ్‌టైప్‌కి నిర్దిష్ట నిర్వచనం అయిన ఈ సూత్రాన్ని బార్బరా లిస్కోవ్ 1987 కాన్ఫరెన్స్ కీనోట్‌లో “డేటా అబ్‌స్ట్రాక్షన్ అండ్ హైరార్కీ” పేరుతో ప్రతిపాదించారు, అందుకే దాని పేరు.
ఇంటర్ఫేస్ స్ప్లిట్ ప్రిన్సిపల్ (ISP)
మరొక SOLID సూత్రం. దాని ప్రకారం, ఉపయోగించని ఇంటర్‌ఫేస్‌ను అమలు చేయకూడదు. ఈ సూత్రాన్ని అనుసరించడం వలన ఆపరేటింగ్ లాజిక్‌కు మార్పులు చేసినప్పుడు సిస్టమ్ అనువైనదిగా మరియు రీఫ్యాక్టరింగ్‌కు అనుకూలంగా ఉండటానికి సహాయపడుతుంది.
చాలా తరచుగా, ఇంటర్ఫేస్ ఒకేసారి అనేక విధులను కలిగి ఉన్నప్పుడు ఈ పరిస్థితి ఏర్పడుతుంది మరియు క్లయింట్‌కు వాటిలో ఒకటి మాత్రమే అవసరం.
ఇంటర్‌ఫేస్‌ను రాయడం చాలా కష్టమైన పని కాబట్టి, పని పూర్తయిన తర్వాత ఏదైనా విచ్ఛిన్నం చేయకుండా మార్చడం సవాలుగా ఉంటుంది.
జావాలో ISP సూత్రం యొక్క ప్రయోజనం ఏమిటంటే, అన్ని పద్ధతులను మొదట అమలు చేయాలి మరియు అప్పుడు మాత్రమే వాటిని తరగతులు ఉపయోగించగలవు. అందువల్ల, సూత్రం పద్ధతుల సంఖ్యను తగ్గించడం సాధ్యం చేస్తుంది.
ఇంటర్ఫేస్ కోసం ప్రోగ్రామింగ్, అమలు కాదు
ఇక్కడ ప్రతిదీ పేరు నుండి స్పష్టంగా ఉంది. ఈ సూత్రాన్ని వర్తింపజేయడం వలన ఇంటర్ఫేస్ యొక్క ఏదైనా కొత్త అమలుతో పని చేయగల సౌకర్యవంతమైన కోడ్ యొక్క సృష్టికి దారి తీస్తుంది.
మీరు వేరియబుల్స్, రిటర్న్ రకాలు లేదా మెథడ్ ఆర్గ్యుమెంట్ రకం కోసం ఇంటర్ఫేస్ రకాన్ని ఉపయోగించాలి. సబ్‌క్లాస్ కాకుండా సూపర్‌క్లాస్‌ని ఉపయోగించడం ఒక ఉదాహరణ.
అంటే:
జాబితా సంఖ్యలు= getNumbers();
కాని కాదు:
అర్రేలిస్ట్ సంఖ్యలు = getNumbers();
పైన చర్చించిన దాని ఆచరణాత్మక అమలు ఇక్కడ ఉంది.
ప్రతినిధి బృందం యొక్క సూత్రం
ఒక సాధారణ ఉదాహరణ జావాలో సమానం() మరియు హాష్‌కోడ్() పద్ధతులు. రెండు వస్తువులను సరిపోల్చాల్సిన అవసరం వచ్చినప్పుడు, ఈ చర్య క్లయింట్ ఒకదానికి బదులుగా సంబంధిత తరగతికి అప్పగించబడుతుంది.
సూత్రం యొక్క ప్రయోజనం ఏమిటంటే కోడ్ యొక్క నకిలీ లేదు మరియు ప్రవర్తనను మార్చడం చాలా సులభం. ఇది ఈవెంట్ డెలిగేషన్‌కు కూడా వర్తిస్తుంది.
ఈ సూత్రాలన్నీ మీరు అధిక సంయోగం మరియు తక్కువ కలయికతో మరింత సౌకర్యవంతమైన, అందమైన మరియు నమ్మదగిన కోడ్‌ను వ్రాయడానికి అనుమతిస్తాయి. వాస్తవానికి, సిద్ధాంతం మంచిది, కానీ డెవలపర్ వాస్తవానికి సంపాదించిన జ్ఞానాన్ని ఉపయోగించడానికి, అభ్యాసం అవసరం. మీరు OOP సూత్రాలను ప్రావీణ్యం పొందిన తర్వాత, మీ తదుపరి దశ సాధారణ సాఫ్ట్‌వేర్ అభివృద్ధి సమస్యలను పరిష్కరించడానికి డిజైన్ నమూనాలను నేర్చుకోవడం.
Skillbox సిఫార్సు చేస్తోంది:
- ప్రాక్టికల్ కోర్సు .
- ఆన్‌లైన్‌లో దరఖాస్తు చేసుకున్నారు .
- రెండేళ్ల ప్రాక్టికల్ కోర్సు .
మూలం: www.habr.com