CodeGym /కోర్సులు /మాడ్యూల్ 1 /ఒక పద్ధతి యొక్క ఫలితం

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

మాడ్యూల్ 1
స్థాయి , పాఠం
అందుబాటులో ఉంది

1. returnప్రకటన

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

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

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.  శ్రేణి పొడవు కంటే  తక్కువగా ఉంటే
లేదా ఎక్కువ ఉంటే , అప్పుడు పద్ధతి వెంటనే ముగుస్తుంది.from0to

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

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

returnప్రకటన ఉపయోగకరంగా ఉంటుంది: ఆచరణాత్మకంగా జావాలోని ప్రతి పద్ధతికి ఒకటి ఉంది మరియు ఇక్కడ ఎందుకు ఉంది.



2. ఫలితంతో పద్ధతులు,void

స్టేట్‌మెంట్‌లు ఉన్నాయని, ఎక్స్‌ప్రెషన్‌లు ఉన్నాయని మనం ఒకసారి గుర్తించామని గుర్తుంచుకోండి . వ్యక్తీకరణ, స్టేట్‌మెంట్‌లా కాకుండా, ఎక్కడో ఉపయోగించగల విలువను కలిగి ఉంటుంది.

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

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

double delta = Math.abs(d1 - d2);
పద్ధతి abs()రెట్టింపును అందిస్తుంది
Scanner console = new Scanner(System.in);
int x = console.nextInt();

పద్ధతి nextInt()ఒక అందిస్తుందిint
String str = "Hello";
String s2 = str.toUpperCase();

పద్ధతి toUpperCase()తిరిగి ఇస్తుంది aString
int[] data = {1, 4, 5, 6, 7, 8, 11};
int[] array = Arrays.copyOf(data, 4);

పద్ధతి copyOf()ఒక అందిస్తుందిint[]

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

public static Type name(parameters)
{
  method body
}

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

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

మీరు మీ స్వంత పద్ధతిని వ్రాస్తున్నారా మరియు కాలింగ్ పద్ధతికి ఏదైనా తిరిగి ఇవ్వకూడదనుకుంటున్నారా? పద్ధతి యొక్క రకాన్ని ఇలా ప్రకటించండి voidమరియు సమస్య పరిష్కరించబడుతుంది. జావాలో కూడా ఇలాంటి పద్ధతులు చాలా ఉన్నాయి.


3. ఫలితాన్ని తిరిగి ఇవ్వడం

గణన ఫలితాన్ని అందించే పద్ధతిని ఎలా ప్రకటించాలో మేము ఇప్పుడే కనుగొన్నాము, అయితే ఈ పద్ధతిలోనే ఈ ఫలితాన్ని ఎలా పొందాలి?

ప్రకటన returnమరోసారి ఇక్కడ మాకు సహాయం చేస్తుంది. ఒక పద్ధతి నుండి ఫలితాన్ని పాస్ చేయడం ఇలా కనిపిస్తుంది:

return value;

returnపద్ధతిని వెంటనే రద్దు చేసే ప్రకటన ఎక్కడ ఉంది. మరియు value అది నిష్క్రమించినప్పుడు పద్ధతి కాలింగ్ పద్ధతికి తిరిగి వచ్చే విలువ. పద్ధతి డిక్లరేషన్‌లో పేర్కొన్న రకంతో valueతప్పనిసరిగా సరిపోలాలి .type

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

int min(int a, int b)
{
   if (a < b)
     return a;
   else
     return b;
}
పద్ధతి కనీసం రెండు సంఖ్యలను అందిస్తుంది. తిరిగితే ,

లేకపోతే తిరిగిa < b
a

b

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

String multiple(String str, int times)
{
   String result = "";
   for (int i = 0; i < times; i++)
     result = result + " "+ str;
   return result;
}
పద్ధతి రెండు పారామితులను తీసుకుంటుంది - ఒక స్ట్రింగ్ మరియు స్ట్రింగ్ ఎన్నిసార్లు పునరావృతం చేయాలి.
భవిష్యత్ ఫలితం కోసం ఖాళీ స్ట్రింగ్ సృష్టించబడింది.

పునరావృతాలతో కూడిన లూప్‌లో times, స్ట్రింగ్‌కు ఖాళీ మరియు strస్ట్రింగ్ జోడించబడతాయి result. పద్ధతి ఫలితంగా

స్ట్రింగ్ తిరిగి ఇవ్వబడుతుంది.result

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

int max(int a, int b)
{
   return (a > b ? a : b);
}
పద్ధతి గరిష్టంగా రెండు సంఖ్యలను అందిస్తుంది.

తిరిగి (అయితే a > b, aలేకపోతే b)

3
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Returning a stack trace
Returning a stack trace
6
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Stack trace revisited
Stack trace revisited
3
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Who called me?
Who called me?
3
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Stack trace with 10 calls
Stack trace with 10 calls
3
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
In the blue depths of the stack trace…
In the blue depths of the stack trace…
3
టాస్క్
జావా సింటాక్స్, స్థాయి, పాఠం
లాక్ చేయబడింది
Logging stack traces
Logging stack traces
వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION