లిస్కోవ్ ప్రత్యామ్నాయం యొక్క సూత్రం, మూడవ SOLID సూత్రం

పిల్లల తరగతులు ఎప్పుడూ పిల్లలను ప్రభావితం చేయకూడదు లేదా సవరించకూడదు defiపేరెంట్ క్లాస్ రకం యొక్క ప్రకటనలు.

ఈ సూత్రం యొక్క భావనను బార్బరా లిస్కోవ్ 1987 కాన్ఫరెన్స్ కీనోట్‌లో ప్రవేశపెట్టారు మరియు తరువాత 1994లో జాన్నెట్ వింగ్‌తో కలిసి ఒక పేపర్‌లో ప్రచురించారు. వారి defiఅసలు tion క్రింది విధంగా ఉంది:

రకం T యొక్క x వస్తువులపై q (x) ప్రదర్శించదగిన ఆస్తిగా ఉండనివ్వండి. అప్పుడు q (y) రకం S యొక్క y వస్తువులకు ప్రదర్శించబడాలి, ఇక్కడ S అనేది T యొక్క ఉప రకం.

తదనంతరం, రాబర్ట్ C. మార్టిన్ యొక్క SOLID సూత్రాలను అతని పుస్తకం ఎజైల్ సాఫ్ట్‌వేర్ డెవలప్‌మెంట్, ప్రిన్సిపల్స్, ప్యాటర్న్స్ మరియు ప్రాక్టీసెస్‌లో ప్రచురించడంతో పాటు, C#లోని ఎజైల్ ప్రిన్సిపల్స్, ప్యాటర్న్స్ మరియు ప్రాక్టీసెస్ పుస్తకం యొక్క C# వెర్షన్‌లో తిరిగి ప్రచురించబడింది. defiఇది లిస్కోవ్ ప్రత్యామ్నాయ సూత్రంగా ప్రసిద్ధి చెందింది.

ఇది మాకు తెస్తుంది defiరాబర్ట్ C. మార్టిన్ అందించిన సమాచారం: ఉప రకాలు వాటి మూల రకాలతో భర్తీ చేయబడాలి.

చాలా సరళంగా, కస్టమర్ యొక్క దృక్కోణం నుండి కార్యాచరణను విచ్ఛిన్నం చేయని విధంగా మాతృ తరగతి యొక్క పద్ధతులను సబ్ క్లాస్ భర్తీ చేయాలి. భావనను ప్రదర్శించడానికి ఇక్కడ ఒక సాధారణ ఉదాహరణ.

తరగతి వాహనం {

    ఫంక్షన్ startEngine () {

        // డిఫాల్ట్ ఇంజిన్ ప్రారంభ కార్యాచరణ

    }

 

    ఫంక్షన్ వేగవంతం () {

        // డిఫాల్ట్ త్వరణం కార్యాచరణ

    }

}

వాహన తరగతి ఇవ్వబడింది - ఇది నైరూప్యంగా ఉంటుంది - మరియు రెండు అమలులు:

తరగతి కారు వాహనాన్ని విస్తరించింది {

    ఫంక్షన్ startEngine () {

        $ ఈ-> ఎంగేజ్ఇగ్నిషన్ ();

        పేరెంట్ :: startEngine ();

    }

 

    ప్రైవేట్ ఫంక్షన్ ఎంగేజ్ఇగ్నిషన్ () {

        // జ్వలన విధానం

    }

}

 

తరగతి ఎలక్ట్రిక్ బస్ వాహనాన్ని విస్తరించింది {

    ఫంక్షన్ వేగవంతం () {

        $ this-> increaseVoltage ();

        $ this-> connectIndividualEngines ();

    }

 

    ప్రైవేట్ ఫంక్షన్ పెరుగుదల వోల్టేజ్ () {

        // ఎలక్ట్రిక్ లాజిక్

    }

 

    ప్రైవేట్ ఫంక్షన్ connectIndividualEngines () {

        // కనెక్షన్ లాజిక్

    }

}

తరగతి డ్రైవర్ {

    ఫంక్షన్ గో (వాహనం $ v) {

        $ v-> startEngine ();

        $ v-> వేగవంతం ();

    }

}

వాహన తరగతి వాహనం ఉపయోగించగలిగితే రెండింటినీ ఉపయోగించగలగాలి.

ఇది మేము OCP లో ఉపయోగించినట్లుగా మూస పద్ధతి రూపకల్పన సరళి యొక్క సరళమైన అమలుకు తీసుకువస్తుంది.

మీరు రెండవ SOLID సూత్రంపై కూడా ఆసక్తి కలిగి ఉండవచ్చు: https: //bloginnovazione.en / open-closed-second-solid-principle / 3906 /

ఓపెన్ / క్లోజ్డ్ సూత్రంతో మా మునుపటి అనుభవం ఆధారంగా, లిస్కోవ్ ప్రత్యామ్నాయ సూత్రం OCP కి దగ్గరి సంబంధం ఉందని మేము నిర్ధారించగలము. వాస్తవానికి, "LSP యొక్క ఉల్లంఘన OCP యొక్క గుప్త ఉల్లంఘన" (రాబర్ట్ సి. మార్టిన్), మరియు మూస విధానం డిజైన్ సరళి LSP యొక్క గౌరవం మరియు అమలుకు ఒక మంచి ఉదాహరణ, ఇది కూడా దీనికి పరిష్కారాలలో ఒకటి OCP తో.

LSP ఉల్లంఘన యొక్క ఉదాహరణ

తరగతి దీర్ఘచతురస్రం {

    ప్రైవేట్ $ టాప్ లెఫ్ట్;

    ప్రైవేట్ $ వెడల్పు;

    ప్రైవేట్ $ ఎత్తు;

 

    పబ్లిక్ ఫంక్షన్ సెట్‌హైట్ ($ ఎత్తు) {

        $ this-> ఎత్తు = $ ఎత్తు;

    }

 

    పబ్లిక్ ఫంక్షన్ getHeight () {

        తిరిగి $ this-> ఎత్తు;

    }

 

    పబ్లిక్ ఫంక్షన్ సెట్విడ్త్ ($ వెడల్పు) {

        $ this-> వెడల్పు = $ వెడల్పు;

    }

 

    పబ్లిక్ ఫంక్షన్ getWidth () {

        తిరిగి $ this-> వెడల్పు;

    }

}

ప్రాథమిక రేఖాగణిత ఆకారం, దీర్ఘచతురస్రంతో ప్రారంభిద్దాం. ఇది వెడల్పు మరియు ఎత్తు కోసం సెట్టర్లు మరియు గెట్టర్లతో కూడిన సాధారణ డేటా ఆబ్జెక్ట్. మా అప్లికేషన్ పనిచేస్తుందని g హించుకోండి మరియు ఇప్పటికే చాలా మంది క్లయింట్‌లపై మోహరించబడింది. ఇప్పుడు వారికి క్రొత్త ఫీచర్ అవసరం. వారు చతురస్రాలను మార్చగలగాలి.

నిజ జీవితంలో, జ్యామితిలో, ఒక చదరపు అనేది దీర్ఘచతురస్రం యొక్క నిర్దిష్ట ఆకారం. కాబట్టి మేము ఒక దీర్ఘచతురస్ర తరగతిని విస్తరించే స్క్వేర్ తరగతిని అమలు చేయడానికి ప్రయత్నించవచ్చు. చైల్డ్ క్లాస్ పేరెంట్ క్లాస్ అని తరచూ చెబుతారు, మరియు ఈ వ్యక్తీకరణ కనీసం మొదటి చూపులోనైనా ఎల్‌ఎస్‌పికి అనుగుణంగా ఉంటుంది.

తరగతి స్క్వేర్ దీర్ఘచతురస్రాన్ని విస్తరించింది {

    పబ్లిక్ ఫంక్షన్ సెట్హైట్ ($ విలువ) {

        $ this-> వెడల్పు = $ విలువ;

        $ this-> ఎత్తు = $ విలువ;

    }

 

    పబ్లిక్ ఫంక్షన్ సెట్విడ్త్ ($ విలువ) {

        $ this-> వెడల్పు = $ విలువ;

        $ this-> ఎత్తు = $ విలువ;

    }

}

చదరపు అనేది సమాన వెడల్పు మరియు ఎత్తు కలిగిన దీర్ఘచతురస్రం మరియు మేము మునుపటి ఉదాహరణలో వలె వింత అమలు చేయవచ్చు. ఎత్తు మరియు వెడల్పు రెండింటినీ సెట్ చేయడానికి మేము రెండు సెట్టర్లను భర్తీ చేయవచ్చు. కానీ ఇది క్లయింట్ కోడ్‌ను ఎలా ప్రభావితం చేస్తుంది?

తరగతి క్లయింట్ {

    ఫంక్షన్ ఏరియా వెరిఫైయర్ (దీర్ఘచతురస్రం $ r) {

        $ r-> సెట్విడ్త్ (5);

        $ r-> సెట్‌హైట్ (4);

        if ($ r-> ప్రాంతం ()! = 20) {

            కొత్త మినహాయింపు త్రో ('చెడ్డ ప్రాంతం!');

        }

        నిజమైన తిరిగి;

    }

}

క్లయింట్ క్లాస్ కలిగి ఉండటం దీర్ఘచతురస్రం యొక్క ప్రాంతాన్ని తనిఖీ చేస్తుంది మరియు తప్పు ఉంటే మినహాయింపు విసిరింది.

ఫంక్షన్ ప్రాంతం () {

    తిరిగి $ this-> వెడల్పు * $ this-> ఎత్తు;

}

ప్రాంతాన్ని అందించడానికి మేము పైన పేర్కొన్న పద్ధతిని మా దీర్ఘచతురస్ర తరగతికి జోడించాము.

తరగతి LspTest PHPUnit_Framework_TestCase s ని విస్తరించింది

    ఫంక్షన్ testRectangleArea () {

        $ r = కొత్త దీర్ఘచతురస్రం ();

        $ c = క్రొత్త క్లయింట్ ();

        $ this-> assertTrue ($ c-> areaVerifier ($ r));

    }

}

మరియు మేము ఏరియా చెకర్‌కు ఖాళీ దీర్ఘచతురస్ర వస్తువును పంపడం ద్వారా సాధారణ పరీక్షను సృష్టించాము మరియు పరీక్ష పాస్‌లు. మా క్లాస్ స్క్వేర్ ఉంటే defiసరిగ్గా nished, దానిని క్లయింట్ యొక్క ఏరియా వెరిఫైయర్()కి పంపడం వలన దాని కార్యాచరణను విచ్ఛిన్నం చేయకూడదు. అన్నింటికంటే, ప్రతి గణిత కోణంలో ఒక చతురస్రం ఒక దీర్ఘ చతురస్రం. అయితే అది మా క్లాసు?

ఫంక్షన్ testSquareArea () {

    $ r = కొత్త స్క్వేర్ ();

    $ c = క్రొత్త క్లయింట్ ();

    $ this-> assertTrue ($ c-> areaVerifier ($ r));

}

కాబట్టి, మా స్క్వేర్ క్లాస్ ఒక దీర్ఘచతురస్రం కాదు. ఇది జ్యామితి నియమాలను ఉల్లంఘిస్తుంది. ఇది విఫలమవుతుంది మరియు లిస్కోవ్ ప్రత్యామ్నాయ సూత్రాన్ని ఉల్లంఘిస్తుంది.

Ercole Palmeri