కాల్ పద్ధతులు, విలువలను తిరిగి ఇవ్వడం

"సరే, మరొక విధానాన్ని ప్రయత్నిద్దాం. కాలింగ్ పద్ధతులు ఎలా పనిచేస్తాయో నేను మీకు చూపిస్తాను, ఆపై మీరు మునుపటి పాఠాన్ని మళ్లీ చదవడానికి ప్రయత్నించండి, సరేనా?"

"మనం చేద్దాం."

"అద్భుతం. నేను మీకు కాల్ చేసే ఫంక్షన్‌లు/పద్ధతులు మరియు అవి తిరిగి ఇచ్చే విలువలు (రిటర్న్ విలువలు) గురించి చెబుతాను."

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

package com.codegym.lesson2;
public class MethodCall
{
    public static void main(String[] args)
    {
         print4("I like to move it, move it.");
    }

    public static void print4(String s)
    {
        System.out.println(s);
        System.out.println(s);
        System.out.println(s);
        System.out.println(s);
    }
}

"పై ఉదాహరణలో, మేము పాస్ చేసిన స్ట్రింగ్‌ను స్క్రీన్‌పై నాలుగు సార్లు ప్రదర్శించే ఒక ఫంక్షన్‌ను వ్రాసాము. ఆపై మేము ఫంక్షన్‌ను print4లైన్ 6లో పిలిచాము."

'I like to move it, move it'"ప్రోగ్రామ్ 6వ పంక్తికి చేరుకున్నప్పుడు, అది వేరియబుల్ sకి విలువను కేటాయిస్తూ లైన్ 9కి చేరుకుంటుంది ."

"అప్పుడు 11-14 పంక్తులు అమలు చేయబడతాయి. ఫంక్షన్ పూర్తవుతుంది మరియు ప్రోగ్రామ్ లైన్ 7లో పునఃప్రారంభించబడుతుంది."

"అలాగా."

"మీరు ఒక ఫంక్షన్‌కు ఆర్గ్యుమెంట్‌లను (విలువలు) పాస్ చేయడమే కాదు-ఒక ఫంక్షన్ దాని పని (రిటర్న్ వాల్యూ) ఫలితాన్ని తిరిగి ఇవ్వగలదు. ఇది కీవర్డ్ రిటర్న్‌తో చేయబడుతుంది. ఇది ఇలా కనిపిస్తుంది:"

public class MethodCall
{
   public static void main(String[] args)
   {
      int a = 5, b = 7;
      int m = min(a, b);
      System.out.println("The minimum is "+ m);
   }

   public static int min(int c, int d)
   {
      int m2;
      if (c < d)
           m2 = c;
      else
           m2 = d;

      return m2;
   }
}

public class MethodCall
{
   public static void main(String[] args)
   {
      int a = 5, b = 7;
      int c = a, d = b;
      int m2;
      if (c < d)
           m2 = c;
      else
           m2 = d;

      int m = m2;
      System.out.println("The minimum is "+ m);
   }
}

"ఇది అర్ధవంతం కావడం ప్రారంభించిందని నేను అనుకుంటున్నాను! ఎడమ మరియు కుడి నిలువు వరుసలలోని కోడ్ వాస్తవానికి ఒకేలా ఉంటుంది. ఎడమ వైపున ఉన్న కోడ్‌కు స్వతంత్ర ఫంక్షన్ ఉంది."

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

"మరియు మీరు చెప్పింది నిజమే!"

"అయితే ఈ శూన్య రకం ఏమిటి?"

"కొన్ని ఫంక్షన్‌లు మా మెయిన్() పద్ధతి వంటి ఏదైనా విలువను కంప్యూట్ చేయకుండా లేదా తిరిగి ఇవ్వకుండానే ఏదో ఒకటి చేస్తాయి . అటువంటి ఫంక్షన్‌ల కోసం ప్రత్యేక రిటర్న్ టైప్– శూన్యం సృష్టించబడింది."

"ఒక ఫంక్షన్ ఏదైనా తిరిగి ఇవ్వకపోతే ఎందుకు ఏమీ ప్రకటించకూడదు?"

"మనం ఏదైనా వేరియబుల్‌ని ఎలా డిక్లేర్ చేస్తారో గుర్తుంచుకోండి? రకం మరియు పేరు. ఫంక్షన్‌ల కోసం, మేము ఒక రకం, పేరు మరియు కుండలీకరణాలను ప్రకటిస్తాము. కుండలీకరణాల తర్వాత ఫంక్షన్ పేరు మీరు ఫంక్షన్‌ను ఎలా పిలుస్తాము."

"కాబట్టి, ఫంక్షన్‌లను రెండు వర్గాలుగా విభజించడం కంటే 'శూన్య రకం'ని కనిపెట్టడం సులభం - విలువలను తిరిగి ఇచ్చేవి మరియు చేయనివి?"

"సరిగ్గా! నువ్వు నిజంగా తెలివైనవాడివి, నా అబ్బాయి."

"శూన్యమైన రకాన్ని మనం ఎలా తిరిగి ఇవ్వాలి?"

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

"పూర్తి m = min(a, b) m = m2గా రూపాంతరం చెందే భాగమని మీ ఉద్దేశ్యం?"

"అవును. ఫంక్షన్ పూర్తయిన తర్వాత, ఫంక్షన్ యొక్క రిటర్న్ విలువ దాని స్థానంలో వ్రాసినట్లుగా ప్రతిదీ పని చేస్తుంది. మీ మనస్సులో ఈ పదబంధాన్ని పునరావృతం చేయండి మరియు చివరి ఉదాహరణలోని కోడ్‌ను చూడండి. "

"ఇది తేలికగా మాత్రమే అనిపిస్తుందని నేను అనుకుంటున్నాను. ఇది నిజానికి కష్టం. నేను దానిలోని భాగాలను మాత్రమే అర్థం చేసుకున్నాను."

"అది సరే. మొదటి ప్రయత్నంలో, మీకు ఇప్పటికే తెలిసిన విషయాలను మాత్రమే మీరు అర్థం చేసుకోగలరు. మీరు అర్థం చేసుకోని ఎక్కువ విషయాలు, మీరు కొత్తదానిలో లోతుగా మునిగిపోతారు మరియు మీ ఫలితాలు మెరుగ్గా ఉంటాయి. ఇది కాలక్రమేణా స్పష్టంగా మారుతుంది. ."

"సరే, నువ్వు చెబితే.. వెళదాం."