పద్ధతి సవరణలు

కోడ్‌జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్‌తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.

"నమస్కారాలు, అమిగో! మీకు ఇప్పటికే పద్ధతులపై మంచి అవగాహన ఉందని నేను విన్నాను?"

"హాయ్, రిషీ. అవును, నేను ఇప్పటికే ఆ టీచర్ యొక్క ట్రిక్ నుండి నా దారిని తగ్గించాను. అది అంత చెడ్డది కాదని నేను చెబుతాను, కానీ మీరు నాకు చెబుతారు, 'వద్దు, లేదు! మీరు ఏమీ గుర్తించలేదు. '"

"మీరు స్పష్టంగా కొంతమంది ఉపాధ్యాయులతో, బహుశా డియెగోతో చాట్ చేస్తూ చాలా సమయం గడుపుతున్నారు. ఏమైనప్పటికీ... మీరు పద్ధతులను బాగా అర్థం చేసుకున్నారని నేను ఇప్పటికీ ఆశిస్తున్నాను. అన్నింటికంటే, ఈ రోజు నేను పద్ధతులను వివరించడంలో సహాయపడే కొన్ని మ్యాజిక్ పదాలను మీకు నేర్పించబోతున్నాను. 'ప్రభావ గోళాలు."

"చమత్కారంగా ఉంది."

"వాస్తవానికి, ఇదంతా చాలా సులభం. ప్రతి పద్ధతికి ముందు, ప్రోగ్రామర్లు యాక్సెస్ మాడిఫైయర్‌లు అని పిలవబడే వాటిని పేర్కొనవచ్చు. వీటిలో క్రింది కీలకపదాలు ఉన్నాయి: public, protected, private.

"ఈ యాక్సెస్ మాడిఫైయర్‌లు ఇతర తరగతుల యాక్సెస్‌ని ఒక పద్ధతికి పరిమితం చేయడానికి మిమ్మల్ని అనుమతిస్తాయి.

"ఉదాహరణకు, మీరు privateమెథడ్ డిక్లరేషన్‌కు ముందు కీవర్డ్‌ని వ్రాస్తే, ఆ పద్ధతిని డిక్లేర్ చేయబడిన అదే క్లాస్ నుండి మాత్రమే పిలవబడుతుంది. కీవర్డ్ publicఏ క్లాస్‌లోని ఏదైనా పద్ధతి నుండి మార్క్ చేసిన పద్ధతికి ప్రాప్యతను అనుమతిస్తుంది.

మొత్తం 3 అటువంటి మాడిఫైయర్‌లు ఉన్నాయి, కానీ ఒక పద్ధతికి 4 రకాల యాక్సెస్‌లు ఉన్నాయి. ఎందుకంటే యాక్సెస్ మాడిఫైయర్ లేకపోవడం కూడా ఏదో అర్థం అవుతుంది. ఇక్కడ పూర్తి పట్టిక ఉంది:

"మరియు ఇక్కడ యాక్సెస్ మాడిఫైయర్‌ల పూర్తి వివరణ ఉంది:

1. publicమాడిఫైయర్

మాడిఫైయర్‌తో గుర్తు పెట్టబడిన పద్ధతి (లేదా వేరియబుల్ లేదా క్లాస్) ప్రోగ్రామ్‌లో ఎక్కడి నుండైనాpublic యాక్సెస్ చేయవచ్చు . ఇది బహిరంగత యొక్క అత్యధిక స్థాయి - ఎటువంటి పరిమితులు లేవు.

2. privateమాడిఫైయర్

మాడిఫైయర్‌తో గుర్తించబడిన పద్ధతి (లేదా వేరియబుల్ లేదా క్లాస్) డిక్లేర్ చేయబడిన అదే తరగతి నుండిprivate మాత్రమే యాక్సెస్ చేయబడుతుంది . అన్ని ఇతర తరగతులకు, గుర్తించబడిన పద్ధతి (లేదా వేరియబుల్) కనిపించదు. అది లేనట్లే. ఇది అత్యున్నత స్థాయి పరిమితి — దాని స్వంత తరగతి మాత్రమే.

3. మాడిఫైయర్ లేదు (డిఫాల్ట్ మాడిఫైయర్)

ఒక పద్ధతి (లేదా వేరియబుల్) ఏదైనా మాడిఫైయర్‌తో గుర్తించబడకపోతే, అది 'డిఫాల్ట్ మాడిఫైయర్'ని కలిగి ఉన్నట్లు పరిగణించబడుతుంది. ఆ మాడిఫైయర్‌తో వేరియబుల్స్ లేదా మెథడ్స్ (అంటే ఏదీ లేనివి) అవి ప్రకటించబడిన ప్యాకేజీలోని అన్ని తరగతులకు కనిపిస్తాయి . మరియు వారికి మాత్రమే. ఈ మాడిఫైయర్‌ని కొన్నిసార్లు అని కూడా పిలుస్తారు package-private, వేరియబుల్స్ మరియు మెథడ్‌లకు యాక్సెస్ వారి క్లాస్ ఉన్న మొత్తం ప్యాకేజీకి తెరిచి ఉంటుందని సూచిస్తుంది.

4. protectedమాడిఫైయర్

ఒక పద్ధతిని మాడిఫైయర్‌తో గుర్తు పెట్టినట్లయితే protected, అది అదే తరగతి, అదే ప్యాకేజీ మరియు వారసులు (పద్ధతి ప్రకటించబడిన తరగతిని వారసత్వంగా పొందిన తరగతులు) నుండి యాక్సెస్ చేయవచ్చు. మేము ఈ అంశాన్ని జావా కోర్ అన్వేషణలో మరింత వివరంగా విశ్లేషిస్తాము."

"ఆసక్తికరంగా ఉంది, కానీ నేను వెంటనే ఈ మాడిఫైయర్‌లను అన్ని సరైన ప్రదేశాలలో ఉంచవచ్చో లేదో నాకు ఖచ్చితంగా తెలియదు.

"మీరు క్రమంగా అక్కడికి చేరుకుంటారు. ముందుగా చింతించాల్సిన అవసరం లేదు. మీరు జావా సింటాక్స్ అన్వేషణ ముగిసే వరకు, మీరు publicమీ అన్ని పద్ధతులపై (అలాగే తరగతులు మరియు ఉదాహరణ వేరియబుల్స్) మాడిఫైయర్‌ను ఉపయోగించవచ్చు. మీకు ఇది అవసరం మేము చురుకుగా OOP నేర్చుకోవడం ప్రారంభించినప్పుడు ఇతర సవరణలు."

"యాక్సెస్ మాడిఫైయర్‌లు ఎందుకు అవసరమో మీరు మరింత వివరంగా వివరించగలరా?"

"ఒకే సమయంలో పదుల మరియు వందల మంది ప్రోగ్రామర్లు వ్రాసిన పెద్ద ప్రాజెక్ట్‌లకు అవి అవసరం అవుతాయి.

"కొన్నిసార్లు ప్రోగ్రామర్ చాలా పెద్ద పద్ధతిని భాగాలుగా విభజించి, కోడ్‌లో కొంత భాగాన్ని సహాయక పద్ధతుల్లోకి తరలించాలని కోరుకునే సందర్భాలు ఉన్నాయి. కానీ అదే సమయంలో, ఇతర ప్రోగ్రామర్లు ఈ సహాయక పద్ధతులను పిలవడం అతను లేదా ఆమె కోరుకోవడం లేదు, ఎందుకంటే సంబంధిత కోడ్ సరిగ్గా పని చేయకపోవచ్చు."

"కాబట్టి వారు ఈ యాక్సెస్ మాడిఫైయర్‌లతో ముందుకు వచ్చారు. మీరు ప్రైవేట్ అనే పదంతో సహాయక పద్ధతిని గుర్తు పెట్టినట్లయితే , మీ తరగతి తప్ప మరే ఇతర కోడ్ మీ సహాయక పద్ధతిని చూడదు."

"నేను అర్థం చేసుకున్నానని అనుకుంటున్నాను."

staticకీవర్డ్

"మరో ఆసక్తికరమైన కీవర్డ్ ఉంది. ఇది static. ఆశ్చర్యకరంగా, ఇది పద్ధతులను స్థిరంగా చేస్తుంది."

"అంటే ఏమిటి?"

"దీని గురించి నేను మీకు తర్వాత చెబుతాను. చింతించకండి. ప్రస్తుతానికి, స్టాటిక్ పద్ధతుల గురించి కొన్ని వాస్తవాలను గుర్తుంచుకోవడానికి ప్రయత్నించండి.

వాస్తవం 1. స్థిరమైన పద్ధతి ఏదైనా వస్తువుకు జోడించబడదు, బదులుగా అది ప్రకటించబడిన తరగతికి చెందినది. స్టాటిక్ పద్ధతిని కాల్ చేయడానికి, మీరు వ్రాయాలి:

ClassName.MethodName()

స్టాటిక్ పద్ధతుల ఉదాహరణలు:

మీరు స్టాటిక్ మెథడ్‌ని దాని క్లాస్‌లోనే కాల్ చేస్తే స్టాటిక్ మెథడ్ పేరు ముందు ఉన్న క్లాస్ పేరు విస్మరించబడుతుంది. అందుకే మీరు పిలిచే ప్రతి స్టాటిక్ పద్ధతుల పేర్లకు ముందు వ్రాయవలసిన అవసరం లేదు.Solution

వాస్తవం 2. ఒక స్టాటిక్ పద్ధతి దాని స్వంత తరగతి యొక్క నాన్-స్టాటిక్ పద్ధతులను యాక్సెస్ చేయదు. స్టాటిక్ మెథడ్ స్టాటిక్ పద్ధతులను మాత్రమే యాక్సెస్ చేయగలదు. ఫలితంగా, మేము mainమెథడ్ స్టాటిక్ నుండి కాల్ చేయాలనుకుంటున్న అన్ని పద్ధతులను ప్రకటిస్తాము."

"అదెందుకు?"

"మీరు OOP నేర్చుకోవడం ప్రారంభించినప్పుడు మరియు స్టాటిక్ పద్ధతులు ఎలా పనిచేస్తాయో అర్థం చేసుకున్నప్పుడు ఈ ప్రశ్నకు మీరే సమాధానం ఇస్తారు. అప్పటి వరకు, నన్ను నమ్మండి.

throwsకీవర్డ్

"మెథడ్ డిక్లరేషన్‌లో మీరు బహుశా చూసిన మరొక కీవర్డ్ ఉంది — కీవర్డ్ throws. యాక్సెస్ మాడిఫైయర్‌లు మరియు కీవర్డ్ కాకుండా , ఈ కీవర్డ్ మెథడ్ పారామీటర్‌ల తర్వాతstatic ఉంచబడుతుంది :

public static Type name(parameters) throws Exception
{
  method body
}

"మరియు దాని అర్థం ఏమిటి?"

"మేము మినహాయింపులను (లెవల్ 15లో) అధ్యయనం చేసినప్పుడు మీరు దాని నిజమైన ఉద్దేశ్యాన్ని తర్వాత నేర్చుకుంటారని మరోసారి నేను మీకు చెప్పాలి.

కానీ దానిని ఉపరితలంగా తాకడానికి, కీవర్డ్‌తో గుర్తించబడిన పద్ధతి throwsలోపాలను (మినహాయింపులు) విసిరివేయగలదని మేము చెప్పగలం, అంటే Exceptionతరగతి యొక్క సందర్భాలు (మరియు దానిని వారసత్వంగా పొందే తరగతులు). ఒక తరగతిలో అనేక రకాల ఎర్రర్‌లు సంభవించినట్లయితే, మీరు వాటిని కామాలతో వేరు చేసి జాబితా చేయాలి."

"రహస్యంగా మరియు అపారమయినదిగా అనిపిస్తోంది! నేను 14వ స్థాయి కోసం వేచి ఉండవలసి ఉంటుంది."

ప్రధాన పద్ధతి

"ఇప్పుడు ప్రధాన పద్ధతిని నిశితంగా పరిశీలిద్దాం. అన్ని మాడిఫైయర్‌లను కలిగి ఉన్న ఒక పద్ధతి ప్రకటించబడిన పంక్తి, ఈ పద్ధతిని ఇతర తరగతులు మరియు పద్ధతుల నుండి ఎలా పిలుస్తారో ప్రభావితం చేస్తుందని మీరు ఇప్పటికే అర్థం చేసుకున్నారు. అదనంగా, ఇది రకాన్ని ప్రభావితం చేస్తుంది ఫలితంగా పద్ధతి తిరిగి వస్తుంది మరియు అది నడుస్తున్నప్పుడు ఏ లోపాలు సాధ్యమో సూచిస్తుంది.

"అటువంటి పంక్తిని మెథడ్ డిక్లరేషన్ అంటారు మరియు కింది సాధారణ ఆకృతిని కలిగి ఉంటుంది:

access modifier static Type name(parameters) throws exceptions

ఎక్కడ , , , లేదా ఏమీ లేకుండా access modifiersభర్తీ చేయబడింది ;publicprotectedprivate

పద్ధతి స్థిరంగా ఉంటే, staticకీవర్డ్ కనిపిస్తుంది (ఇది నాన్-స్టాటిక్ పద్ధతులకు లేదు)

Typeరిటర్న్ విలువ రకం ( voidఫలితం లేకపోతే)

"పద్ధతి యొక్క ప్రకటనలో ఈ పదాలన్నీ అర్థం ఏమిటో ఇప్పుడు మీరు బాగా అర్థం చేసుకున్నారు main:

public static void main(String[] args) throws Exception

main()"సరే, కీవర్డ్ ద్వారా సూచించిన విధంగా ఏ తరగతి నుండైనా పద్ధతికి ప్రాప్యత సాధ్యమవుతుందని ఇప్పుడు నేను గ్రహించాను public. పద్ధతి స్థిరంగా ఉంటుంది, కాబట్టి దీనిని స్పష్టంగా ఇలా పిలవవచ్చు Solution.main()."

"పద్ధతి ఏ ఫలితాన్ని main()ఇస్తుంది?"

"ఏదీ లేదు! ఫలితం రకం void. ఇది ఖాళీ రకం, ప్లేస్‌హోల్డర్ లాంటిది."

main()" దాని కుండలీకరణాల్లో ఏమి ఉంది?"

"హ్మ్... పద్ధతి వాదనలు (!) తీసుకుంటుందని తేలింది main. అవి స్ట్రింగ్‌ల శ్రేణిగా పంపబడతాయి."

"అది సరియైనది. మరియు పారామీటర్ పేరు మన మనస్సులకు 'వాదనలు' సూచిస్తుంది. ప్రోగ్రామ్ ప్రారంభమైనప్పుడు, మీరు ఆర్గ్యుమెంట్‌లను పాస్ చేయవచ్చు — స్ట్రింగ్‌ల శ్రేణి. అవి పద్ధతిలోని శ్రేణిలో argsఉంటాయి. "argsmain()

"అయ్యో! నేను మొదటిసారి చూసినప్పుడు దీని గురించి ఆశ్చర్యపోయాను, కానీ తరువాత అలవాటుపడి, ఆలోచించకుండా పారామీటర్ జాబితా రాయడం ప్రారంభించాను."

"మనమందరం అక్కడ ఉన్నాము. చివరగా, Exception(లేదా దాని వారసులు) వంటి హ్యాండిల్ చేయని లోపాలు ఈ పద్ధతిలో సంభవించవచ్చు . ఇది డిక్లరేషన్‌లోని భాగానికి main()ధన్యవాదాలు ."throws Exception

"ధన్యవాదాలు, రిషీ. నాకు ప్రతిదీ అర్థం కాలేదు, కానీ ఇది ఆసక్తికరంగా ఉంది."

"మీకు స్వాగతం. క్రమంగా మీరు ఈ సూక్ష్మమైన అంశాలన్నింటినీ అర్థం చేసుకుంటారు, నేను ఖచ్చితంగా అనుకుంటున్నాను."