ఒక పద్ధతి యొక్క ఫలితం

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

"మీరు మళ్ళీ, అమిగో. సరే, హలో."

"నన్ను చూసి మీరు చాలా సంతోషంగా లేరనిపిస్తోంది, డియెగో?"

"జావాలో పద్ధతుల గురించి తెలుసుకోవలసిన ప్రతిదాన్ని మీరు ఇప్పటికే నేర్చుకున్నారని మీరు భావిస్తున్నారనే అభిప్రాయాన్ని నేను పొందాను."

"అయ్యో, నేను చేయను..."

"అలా అనుకోవడం లేదు! నీకు సగం కూడా తెలీదు."

"ఖచ్చితంగా, నేను విభేదించను ...

"సరే, తగినంత మాట్లాడండి. ఇది ప్రారంభించడానికి సమయం. మరియు మేము సరళమైన దానితో ప్రారంభిస్తాము. ఉదాహరణకు, జావా రిటర్న్ స్టేట్‌మెంట్‌ని కలిగి ఉన్న వాస్తవం . ఇది పిలిచే పద్ధతిని తక్షణమే ముగించడానికి మిమ్మల్ని అనుమతిస్తుంది. ఇక్కడ ప్రకటన ఉంది:

return;

return"ఇది చాలా సులభం: సెమికోలన్ తర్వాత ఏకాంత పదం . ప్రోగ్రామ్ ఈ ప్రకటనను అమలు చేసిన వెంటనే, ప్రస్తుత పద్ధతి నిష్క్రమిస్తుంది మరియు కాలింగ్ పద్ధతి కొనసాగుతుంది.

" returnపద్ధతిలో పిలిస్తే main, పద్ధతి mainవెంటనే ముగుస్తుంది మరియు దానితో మొత్తం ప్రోగ్రామ్.

ఉదాహరణ:

class Solution
{
   public static void fill(int[] data, int from, int to, int value)
   {
     if (from < 0 || to > data.length)
       return;

     for (int i = from; i < to; i++)
     {
       data[i] = value;
     }
   }

   public static void main(String[] args)
   {
     int[] months = {1, 2, 3, 4, 5, 6, 7, 8 ,9, 10, 11, 12};
     fill(months, 2, 10, 8);
   }
}

"పై ప్రోగ్రామ్‌కి fillపంపబడిన శ్రేణిని పూరించే పద్ధతి ఉంది value. ఇది మొత్తం శ్రేణిని పూరించదు, సూచికలు పేర్కొన్న భాగాన్ని మాత్రమే fromమరియు to.

"పద్ధతి ప్రారంభంలో fill, ఆమోదించబడిన విలువలు చెల్లుబాటులో ఉన్నాయని నిర్ధారించడానికి తనిఖీ చేయబడతాయి. from0 కంటే తక్కువగా ఉంటే లేదా toశ్రేణి పొడవు కంటే ఎక్కువ ఉంటే, ఆ fillపద్ధతి వెంటనే ముగుస్తుంది (ఒక returnప్రకటనను అమలు చేస్తుంది)."

"అర్థమైంది. ఈ స్టేట్మెంట్ అంతా ఇంతేనా?"

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

ఫలితంతో కూడిన పద్ధతులు,void

"ప్రకటనలు ఉన్నాయని మరియు వ్యక్తీకరణలు ఉన్నాయని మీరు బహుశా గుర్తుంచుకోవాలి . వాటి మధ్య తేడా ఏమిటి?"

"నేను తప్పుగా భావించనట్లయితే, ఒక వ్యక్తీకరణ, ఒక ప్రకటన వలె కాకుండా, ఎక్కడో ఉపయోగించగల అర్థాన్ని కలిగి ఉంటుంది."

"సరైనది. మరియు, జావాలో, పద్ధతులు కూడా విలువను కలిగి ఉంటాయి . మరియు ఇది చాలా శుభవార్త: పద్ధతులు ఇన్‌పుట్ పారామితుల ఆధారంగా ఏదైనా చేయగలవు, కానీ, ఉదాహరణకు, ఏదైనా మూల్యాంకనం చేయడం మరియు ఫలితాన్ని తిరిగి ఇవ్వడం గణన _

"మార్గం ద్వారా, మీరు ఇప్పటికే ఇటువంటి పద్ధతులను ఎదుర్కొన్నారు:

double delta = Math.abs(d1 - d2);

Scanner console = new Scanner(System.in);
int x = console.nextInt();

String str = "Hello";
String s2 = str.toUpperCase();

int[] data = {1, 4, 5, 6, 7, 8, 11};
int[] array = Arrays.copyOf(data, 4);

"ప్రతి పద్ధతి ముందుగా నిర్ణయించిన రకానికి చెందిన ఒక విలువను మాత్రమే అందించగలదు . పద్ధతి ప్రకటించబడినప్పుడు రిటర్న్ రకం నిర్ణయించబడుతుంది:

public static Type name(parameters)
{
  method body
}

nameమెథడ్ పేరు ఎక్కడ ఉంది, parametersమెథడ్ పారామితుల జాబితా, మరియు typeపద్ధతి తిరిగి ఇచ్చే ఫలితం రకం.

ఏమీ తిరిగి ఇవ్వని పద్ధతుల కోసం, ప్రత్యేక ప్లేస్‌హోల్డర్ రకం ఉంది: void.

"మరో మాటలో చెప్పాలంటే, నేను నా పద్ధతిని వ్రాసి, దేనినీ తిరిగి ఇవ్వకూడదనుకుంటే, ఆ పద్ధతి యొక్క రకాన్ని నేను ప్రకటిస్తాను void, అంతేనా?"

"అవును. మరియు, జావాలో ఇలాంటి పద్ధతులు చాలా ఉన్నాయని నేను చెప్పాలి.

ఫలితం తిరిగి వస్తుంది

"ఒక గణన/పని యొక్క ఫలితాన్ని తిరిగి ఇచ్చే పద్ధతిని ఎలా ప్రకటించాలో నేను కనుగొన్నాను. నేను పద్ధతి నుండి ఫలితాన్ని ఎలా తిరిగి ఇవ్వగలను?"

"ఇది చెల్లుబాటు అయ్యే ప్రశ్న. returnస్టేట్‌మెంట్ ఇక్కడ మరోసారి మాకు సహాయం చేస్తుంది. పద్ధతి నుండి ఫలితాన్ని అందించడం ఇలా కనిపిస్తుంది:

return value;

" returnస్టేట్‌మెంట్ పద్ధతిని వెంటనే రద్దు చేస్తుంది. మరియు అది నిష్క్రమించినప్పుడు ఆ పద్ధతి కాలింగ్ పద్ధతికి తిరిగి రావాలి. పద్ధతి డిక్లరేషన్‌లో పేర్కొన్న valueరకంతో valueసరిపోలాలి . మీరు నేర్చుకున్న వాటిని బలోపేతం చేయడానికి ఇక్కడ కొన్ని ఉదాహరణలు ఉన్నాయి:Type

ఉదాహరణ 1. పద్ధతి కనిష్టంగా రెండు సంఖ్యలను గణిస్తుంది:

int min(int a, int b)
{
   if (a < b)
     return a;
   else
     return b;
}

ఉదాహరణ 2. పద్దతి దానికి పంపిన స్ట్రింగ్ nసమయాలను నకిలీ చేస్తుంది:

String multiple(String str, int times)
{
   String result = "";

   for (int i = 0; i < times; i++);
     result = result + " "+ str;
   return result;
}

ఉదాహరణ 3: టెర్నరీ ఆపరేటర్‌ని ఉపయోగించి పద్ధతి గరిష్టంగా రెండు సంఖ్యలను గణిస్తుంది:

int max(int a, int b)
{
   return (a > b ? a : b);
}

"అద్భుతం. పద్ధతులు నా కొత్త సూపర్ పవర్!"

"మీరు చేయవలసిన పనులలో తగినంత సాధన చేస్తే మాత్రమే. పైగా మరియు వెలుపల."