కోడ్జిమ్ విశ్వవిద్యాలయం కోర్సులో భాగంగా మెంటర్తో ఉపన్యాస స్నిప్పెట్. పూర్తి కోర్సు కోసం సైన్ అప్ చేయండి.
"మీరు మళ్ళీ, అమిగో. సరే, హలో."
"నన్ను చూసి మీరు చాలా సంతోషంగా లేరనిపిస్తోంది, డియెగో?"
"జావాలో పద్ధతుల గురించి తెలుసుకోవలసిన ప్రతిదాన్ని మీరు ఇప్పటికే నేర్చుకున్నారని మీరు భావిస్తున్నారనే అభిప్రాయాన్ని నేను పొందాను."
"అయ్యో, నేను చేయను..."
"అలా అనుకోవడం లేదు! నీకు సగం కూడా తెలీదు."
"ఖచ్చితంగా, నేను విభేదించను ...
"సరే, తగినంత మాట్లాడండి. ఇది ప్రారంభించడానికి సమయం. మరియు మేము సరళమైన దానితో ప్రారంభిస్తాము. ఉదాహరణకు, జావా రిటర్న్ స్టేట్మెంట్ని కలిగి ఉన్న వాస్తవం . ఇది పిలిచే పద్ధతిని తక్షణమే ముగించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇక్కడ ప్రకటన ఉంది:
return;
return
"ఇది చాలా సులభం: సెమికోలన్ తర్వాత ఏకాంత పదం . ప్రోగ్రామ్ ఈ ప్రకటనను అమలు చేసిన వెంటనే, ప్రస్తుత పద్ధతి నిష్క్రమిస్తుంది మరియు కాలింగ్ పద్ధతి కొనసాగుతుంది.
" return
పద్ధతిలో పిలిస్తే main
, పద్ధతి main
వెంటనే ముగుస్తుంది మరియు దానితో మొత్తం ప్రోగ్రామ్.
ఉదాహరణ:
|
ఈ fill పద్ధతి ఆమోదించబడిన శ్రేణిలో కొంత భాగాన్ని తో నింపుతుంది value . పూరించవలసిన శ్రేణి యొక్క భాగం సూచికల ద్వారా నిర్వచించబడుతుంది from మరియు to . శ్రేణి పొడవు కంటే తక్కువగా ఉంటే లేదా ఎక్కువ ఉంటే , అప్పుడు పద్ధతి వెంటనే ముగుస్తుంది. from 0 to |
"పై ప్రోగ్రామ్కి fill
పంపబడిన శ్రేణిని పూరించే పద్ధతి ఉంది value
. ఇది మొత్తం శ్రేణిని పూరించదు, సూచికలు పేర్కొన్న భాగాన్ని మాత్రమే from
మరియు to
.
"పద్ధతి ప్రారంభంలో fill
, ఆమోదించబడిన విలువలు చెల్లుబాటులో ఉన్నాయని నిర్ధారించడానికి తనిఖీ చేయబడతాయి. from
0 కంటే తక్కువగా ఉంటే లేదా to
శ్రేణి పొడవు కంటే ఎక్కువ ఉంటే, ఆ fill
పద్ధతి వెంటనే ముగుస్తుంది (ఒక return
ప్రకటనను అమలు చేస్తుంది)."
"అర్థమైంది. ఈ స్టేట్మెంట్ అంతా ఇంతేనా?"
"వాస్తవానికి, return
ప్రకటన మీరు అనుకున్నదానికంటే చాలా ఉపయోగకరంగా ఉంది. ఇది చాలా ఉపయోగకరంగా ఉంది, ఇది జావాలోని దాదాపు ప్రతి పద్ధతిలో కనుగొనబడింది. మరియు ఇది ఎందుకు అనేదానిపై ఇప్పుడు నేను మీకు అవగాహన కల్పిస్తాను.
ఫలితంతో కూడిన పద్ధతులు,void
"ప్రకటనలు ఉన్నాయని మరియు వ్యక్తీకరణలు ఉన్నాయని మీరు బహుశా గుర్తుంచుకోవాలి . వాటి మధ్య తేడా ఏమిటి?"
"నేను తప్పుగా భావించనట్లయితే, ఒక వ్యక్తీకరణ, ఒక ప్రకటన వలె కాకుండా, ఎక్కడో ఉపయోగించగల అర్థాన్ని కలిగి ఉంటుంది."
"సరైనది. మరియు, జావాలో, పద్ధతులు కూడా విలువను కలిగి ఉంటాయి . మరియు ఇది చాలా శుభవార్త: పద్ధతులు ఇన్పుట్ పారామితుల ఆధారంగా ఏదైనా చేయగలవు, కానీ, ఉదాహరణకు, ఏదైనా మూల్యాంకనం చేయడం మరియు ఫలితాన్ని తిరిగి ఇవ్వడం గణన _
"మార్గం ద్వారా, మీరు ఇప్పటికే ఇటువంటి పద్ధతులను ఎదుర్కొన్నారు:
|
పద్ధతి abs() రెట్టింపును అందిస్తుంది |
|
పద్ధతి nextInt() ఒక అందిస్తుందిint |
|
పద్ధతి toUpperCase() తిరిగి ఇస్తుంది aString |
|
పద్ధతి copyOf() ఒక అందిస్తుందిint[] |
"ప్రతి పద్ధతి ముందుగా నిర్ణయించిన రకానికి చెందిన ఒక విలువను మాత్రమే అందించగలదు . పద్ధతి ప్రకటించబడినప్పుడు రిటర్న్ రకం నిర్ణయించబడుతుంది:
public static Type name(parameters)
{
method body
}
name
మెథడ్ పేరు ఎక్కడ ఉంది, parameters
మెథడ్ పారామితుల జాబితా, మరియు type
పద్ధతి తిరిగి ఇచ్చే ఫలితం రకం.
ఏమీ తిరిగి ఇవ్వని పద్ధతుల కోసం, ప్రత్యేక ప్లేస్హోల్డర్ రకం ఉంది: void
.
"మరో మాటలో చెప్పాలంటే, నేను నా పద్ధతిని వ్రాసి, దేనినీ తిరిగి ఇవ్వకూడదనుకుంటే, ఆ పద్ధతి యొక్క రకాన్ని నేను ప్రకటిస్తాను void
, అంతేనా?"
"అవును. మరియు, జావాలో ఇలాంటి పద్ధతులు చాలా ఉన్నాయని నేను చెప్పాలి.
ఫలితం తిరిగి వస్తుంది
"ఒక గణన/పని యొక్క ఫలితాన్ని తిరిగి ఇచ్చే పద్ధతిని ఎలా ప్రకటించాలో నేను కనుగొన్నాను. నేను పద్ధతి నుండి ఫలితాన్ని ఎలా తిరిగి ఇవ్వగలను?"
"ఇది చెల్లుబాటు అయ్యే ప్రశ్న. return
స్టేట్మెంట్ ఇక్కడ మరోసారి మాకు సహాయం చేస్తుంది. పద్ధతి నుండి ఫలితాన్ని అందించడం ఇలా కనిపిస్తుంది:
return value;
" return
స్టేట్మెంట్ పద్ధతిని వెంటనే రద్దు చేస్తుంది. మరియు అది నిష్క్రమించినప్పుడు ఆ పద్ధతి కాలింగ్ పద్ధతికి తిరిగి రావాలి. పద్ధతి డిక్లరేషన్లో పేర్కొన్న value
రకంతో value
సరిపోలాలి . మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:Type
ఉదాహరణ 1. పద్ధతి కనిష్టంగా రెండు సంఖ్యలను గణిస్తుంది:
|
పద్ధతి కనీసం రెండు సంఖ్యలను అందిస్తుంది. తిరిగితే , లేకపోతే తిరిగి a < b a b |
ఉదాహరణ 2. పద్దతి దానికి పంపిన స్ట్రింగ్ n
సమయాలను నకిలీ చేస్తుంది:
|
పద్ధతి రెండు పారామితులను తీసుకుంటుంది - ఒక స్ట్రింగ్ మరియు స్ట్రింగ్ ఎన్నిసార్లు పునరావృతం చేయాలి. భవిష్యత్ ఫలితం కోసం ఖాళీ స్ట్రింగ్ సృష్టించబడింది. పునరావృతాలతో కూడిన లూప్లో times , స్ట్రింగ్కు ఖాళీ మరియు స్ట్రింగ్ str జోడించబడతాయి result . పద్ధతి ఫలితంగా స్ట్రింగ్ తిరిగి ఇవ్వబడుతుంది. result |
ఉదాహరణ 3: టెర్నరీ ఆపరేటర్ని ఉపయోగించి పద్ధతి గరిష్టంగా రెండు సంఖ్యలను గణిస్తుంది:
|
పద్ధతి గరిష్టంగా రెండు సంఖ్యలను అందిస్తుంది. తిరిగి (అయితే a > b , a లేకపోతే b ) |
"అద్భుతం. పద్ధతులు నా కొత్త సూపర్ పవర్!"
"మీరు చేయవలసిన పనులలో తగినంత సాధన చేస్తే మాత్రమే. పైగా మరియు వెలుపల."
GO TO FULL VERSION