అని పిలువబడే ప్రోగ్రామింగ్ నమూనా ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ (OOP) మాడ్యులర్, పునర్వినియోగ ప్రోగ్రామ్‌లను వ్రాయడానికి వినియోగదారులను అనుమతిస్తుంది. స్థిరమైన తరగతిలో ఉపయోగించడం OOP యొక్క లక్షణాలలో ఒకటి. తరగతి స్థిరాంకాలు PHPలో అవి పేర్కొన్న తర్వాత మార్చలేని విలువలు. వారు తరగతి సభ్యులు మరియు నిర్దిష్ట తరగతి ఉదాహరణతో అనుబంధించబడరు.
PHPలో క్లాస్ స్థిరాంకాలు అంటే ఏమిటి?
ప్రారంభించడానికి, తరగతి స్థిరాంకాలు స్క్రిప్ట్ సమయంలో స్థిరంగా ఉండే విలువను సూచించండి. OOPలో, ఇది క్లాస్‌లో నిర్దిష్ట అర్థాన్ని కలిగి ఉండే విలువను నిర్వచించడానికి ప్రోగ్రామర్‌ను అనుమతిస్తుంది మరియు ఏ క్లాస్ పద్ధతుల ద్వారా నవీకరించబడదు. ది స్థిరంగా పేర్కొనడానికి కీవర్డ్ ఉపయోగించబడుతుంది తరగతి స్థిరాంకాలు , ఇది స్క్రిప్ట్ సమయంలో స్థిరమైన విలువ ఇవ్వబడుతుంది.
ఎ తరగతి స్థిరాంకం ప్రోగ్రామ్ యొక్క అమలు అంతటా స్థిరంగా ఉండే తరగతిలో నిర్వచించబడిన విలువ. పదం స్థిరంగా వాటిని నిర్వచించడానికి ఉపయోగించబడుతుంది, తర్వాత ఆ స్థిరాంకం యొక్క పేరు మరియు విలువ ఉంటుంది. నిర్వచించిన తర్వాత, వాటిని రన్‌టైమ్‌లో మార్చలేరు.
ఉదాహరణకు, మనం a ని నిర్వచించవచ్చు తరగతి స్థిరాంకం కింది పద్ధతిలో Pi విలువ కోసం:
తరగతి గణితం {
const PI = 3.14 ;
}
ఇక్కడ, మేము నిర్వచించాము తరగతి స్థిరాంకం PI గణిత తరగతికి 3.14. స్థిరాంకం క్లాస్‌తో ముడిపడి ఉంది మరియు క్లాస్ యొక్క ఉదాహరణ కాదు కాబట్టి, మేము దీన్ని ఇన్‌స్టాన్స్ లేకుండా యాక్సెస్ చేయవచ్చు:
ప్రతిధ్వని గణితం :: PI;
సాధారణ వేరియబుల్స్‌తో పోలిస్తే, తరగతి స్థిరాంకాలు కొన్ని గుర్తించదగిన తేడాలు ఉన్నాయి. మొదట, అవి మార్పులేనివి, అంటే, వాటిని ఒకసారి నిర్వచించిన తర్వాత మార్చలేము. రెండవది, స్థిరమైన విలువలు PHPలోని వేరియబుల్స్ వలె కాకుండా, కేస్-సెన్సిటివ్. ఇంకా, స్థిరాంకాలు ఉపయోగించి నిర్వచించబడతాయి స్థిరంగా కీవర్డ్, అయితే వేరియబుల్స్ ఉపయోగిస్తాయి ఉంది కీవర్డ్, ఇది ఒక ముఖ్యమైన వ్యత్యాసం.
క్లాస్ స్థిరాంకాలను యాక్సెస్ చేస్తోంది
యాక్సెస్ చేస్తోంది తరగతి స్థిరాంకాలు రెండు విధాలుగా చేయవచ్చు.
1: స్కోప్ రిజల్యూషన్ ఉపయోగించడం (::)
ముందుగా, ది తరగతి స్థిరాంకాలు ఉపయోగించి యాక్సెస్ చేయవచ్చు పరిధి స్పష్టత (::) ఆపరేటర్, ఇలా:
తరగతి పేరు::CONSTANT_NAME
ఒక ఉదాహరణ చూడండి:
తరగతి వ్యక్తి {
const పేరు = 'లారీ' ;
const Age = 32 ;
const జాతీయత = 'అమెరికన్' ;
}
ప్రతిధ్వని వ్యక్తి::పేరు, ' \n ' ;
ప్రతిధ్వని వ్యక్తి::వయస్సు, ' \n ' ;
ప్రతిధ్వని వ్యక్తి::జాతీయత;
? >
పై కోడ్‌లో, ది వ్యక్తి తరగతి పేరు, వయస్సు మరియు జాతీయతను మూడుగా పేర్కొంటుంది స్థిరాంకాలు . ప్రతి స్థిరాంకం దాని కోసం నిర్వచించబడిన స్ట్రింగ్ లేదా పూర్ణాంకం విలువను కలిగి ఉంటుంది.
ది :: ఆపరేటర్ అనేది క్లాస్ స్థిరాంకం యొక్క విలువను యాక్సెస్ చేయడానికి స్థిరమైన పేరుతో కలిపి ఉపయోగించబడుతుంది. ఉదాహరణకు, మేము వాక్యనిర్మాణాన్ని ఉపయోగిస్తాము వ్యక్తి::పేరు యొక్క విలువను తిరిగి పొందడానికి పేరు స్థిరమైన.
చివరగా, మేము ఎకో కమాండ్‌ని ఉపయోగించి స్క్రీన్‌పై పేరు, వయస్సు మరియు జాతీయత స్థిరాంకాల విలువలను ముద్రిస్తాము.
2: 'సెల్ఫ్' కీవర్డ్‌ని ఉపయోగించడం
ప్రత్యామ్నాయంగా, మేము కూడా యాక్సెస్ చేయవచ్చు తరగతి స్థిరాంకాలు తరగతిలోనే ఉపయోగించి `సెల్ఫ్` కీవర్డ్ తర్వాత స్థిరమైన పేరు క్రింద ఇవ్వబడింది:
స్వీయ::CONSTANT_NAME
ఉపయోగించి స్థిరాంకాన్ని యాక్సెస్ చేయడానికి ఒక ఉదాహరణను చూడండి స్వీయ కీవర్డ్.
తరగతి సర్కిల్ {
const PI = 3.14159 ;
ప్రైవేట్ $ వ్యాసార్థం ;
ప్రజా ఫంక్షన్ __నిర్మాణం ( $ వ్యాసార్థం ) {
$ఇది - > వ్యాసార్థం = $ వ్యాసార్థం ;
}
ప్రజా ఫంక్షన్ ప్రాంతం ( ) {
తిరిగి స్వీయ :: PI * $ఇది - > వ్యాసార్థం * $ఇది - > వ్యాసార్థం;
}
}
$ సర్కిల్ = కొత్త సర్కిల్ ( 16 ) ;
ప్రతిధ్వని $ సర్కిల్ - > ప్రాంతం ( ) ;
? >
ఈ ఎగువ ఉదాహరణలో, సర్కిల్ అనే తరగతి $రేడియస్ అని పిలువబడే ప్రైవేట్ ఆస్తిని మరియు PI అని పిలువబడే స్థిరాంకాన్ని నిర్దేశిస్తుంది. ఉపయోగించే సూత్రం getArea() ఒక వృత్తం యొక్క వైశాల్యాన్ని పొందడానికి ఫంక్షన్ PI * వ్యాసార్థం * వ్యాసార్థం , ఇక్కడ PI అనేది PI స్థిరాంకం యొక్క విలువ మరియు వ్యాసార్థం $ వ్యాసార్థం పరామితి యొక్క విలువ.
లోపల getArea() పద్ధతి, మేము ఉపయోగిస్తాము స్వీయ PI స్థిరాంకం యొక్క విలువను పొందడానికి స్థిరమైన పేరును అనుసరించే కీవర్డ్: స్వీయ :: PI .
నిర్వచించేటప్పుడు గుర్తుంచుకోవలసిన కొన్ని పరిగణనలు ఉన్నాయి తరగతి స్థిరాంకాలు . ముందుగా, తరగతి స్థిరాంకం పేరు తరగతిలోనే ప్రత్యేకంగా ఉండేలా చూసుకోండి. రెండవది, ఇది క్లాస్ పేర్ల వలె అదే నామకరణ సంప్రదాయాలకు కట్టుబడి ఉండాలి, అది స్థిరాంకాల కోసం ఒంటె కేస్‌ను ఉపయోగిస్తుంది. చివరగా, పూర్ణాంకాలు మరియు స్ట్రింగ్స్ వంటి స్కేలార్ విలువలను మాత్రమే నిర్వచించడం మంచి పద్ధతి తరగతి స్థిరాంకాలు .
తరగతి స్థిరాంకాల వారసత్వం
యొక్క మరొక ముఖ్యమైన లక్షణం తరగతి స్థిరాంకాలు వారు పిల్లల తరగతుల ద్వారా వారసత్వంగా పొందవచ్చు. సారాంశంలో, ఒక సబ్‌క్లాస్ దాని మాతృ తరగతి ద్వారా నిర్వచించబడిన స్థిరమైన విలువలను ఉపయోగించి యాక్సెస్ చేయగలదు తల్లిదండ్రులు కీవర్డ్. ఉదాహరణకి:
< ?phpతరగతి జంతువు {
కాన్స్ట్ ANIMAL_TYPE = 'క్షీరదం' ;
}
తరగతి కుక్క జంతువును విస్తరించింది {
ప్రజా ఫంక్షన్ getType ( ) {
ప్రతిధ్వని 'కుక్క ఒక' , పేరెంట్::ANIMAL_TYPE;
}
}
$ కుక్క = కొత్త కుక్క ( ) ;
$ కుక్క - > getType ( ) ;
? >
ఈ దృష్టాంతంలో, క్లాస్ యానిమల్ విలువతో స్థిరంగా ఉంటుంది ' క్షీరదం ' అనే ANIMAL_TYPE . ది కుక్క అనేది యానిమల్ క్లాస్ నుండి ఉద్భవించిన ఉపవర్గం.
పబ్లిక్ ఫంక్షన్ getType() డాగ్ క్లాస్ యొక్క విలువను కేవలం అవుట్‌పుట్ చేస్తుంది ఎ NIMAL_TYPE మాతృ తరగతి స్థిరాంకాన్ని యాక్సెస్ చేయడం ద్వారా స్థిరంగా పేరెంట్::కీవర్డ్ .
చివరగా, మేము డాగ్ క్లాస్ ఆబ్జెక్ట్‌ని నిర్మించాము మరియు దానిని ఉపయోగిస్తాము getType() ఫంక్షన్, ఇది యానిమల్ క్లాస్ యొక్క వారసత్వ స్థిరాంకం యొక్క విలువను అందిస్తుంది ANIMAL_TYPE .
ముగింపు
దాని యొక్క ఉపయోగం తరగతి స్థిరాంకాలు PHP మరియు ఇతర ప్రోగ్రామింగ్ భాషలలో ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్‌లో కీలక భాగం . ఉపయోగించడం ద్వార తరగతి స్థిరాంకాలు , మేము ప్రోగ్రామ్‌లో హార్డ్-కోడెడ్ విలువలను నివారించవచ్చు, ఇది కోడ్‌ను అప్‌డేట్ చేసేటప్పుడు అవాంతరం కావచ్చు. నామకరణ సంప్రదాయాలకు కట్టుబడి ఉండటం మరియు వాటిని నిర్వచించేటప్పుడు ప్రోగ్రామ్‌లోని క్లాస్ స్థిరాంకాల ప్రాప్యతను గుర్తుంచుకోవడం ముఖ్యం.