அழைப்பு முறைகள், மதிப்புகள் திரும்பும்

"சரி, வேறொரு அணுகுமுறையை முயற்சிப்போம். அழைப்பு முறைகள் எவ்வாறு செயல்படுகின்றன என்பதை நான் உங்களுக்குக் காட்டுகிறேன், பிறகு நீங்கள் முந்தைய பாடத்தை மீண்டும் படிக்க முயற்சி செய்யுங்கள், சரி?"

"செய்வோம்."

"அருமை. அழைப்பு செயல்பாடுகள்/முறைகள் மற்றும் அவை வழங்கும் மதிப்புகள் (திரும்ப மதிப்புகள்) பற்றி நான் உங்களுக்கு சொல்கிறேன்."

"கட்டளைகள், அல்லது அறிக்கைகள், முறைகளாக தொகுக்கப்படுகின்றன, எனவே அவை ஒற்றைத் தொகுதியாக, ஒரு சிக்கலான கட்டளையைப் போன்று செயல்படுத்தப்படும். இதைச் செய்ய, நீங்கள் முறை (செயல்பாடு) பெயரை எழுத வேண்டும், பின்னர் அடைப்புக்குறிக்குள் முறையின் வாதங்களை பட்டியலிட வேண்டும்."

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);
    }
}

"மேலே உள்ள எடுத்துக்காட்டில், அனுப்பப்பட்ட சரத்தை திரையில் நான்கு முறை காண்பிக்கும் ஒரு செயல்பாட்டை நாங்கள் எழுதினோம். பின்னர் நாங்கள் print46 ஆம் வரியில் செயல்பாட்டை அழைத்தோம்."

"நிரல் வரி 6 ஐ அடையும் போது, ​​அது வரி 9 க்கு தாவி, 'I like to move it, move it'மாறி s க்கு மதிப்பை ஒதுக்கும்."

"பின்னர் 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);
   }
}

"இது அர்த்தமுள்ளதாக நான் நினைக்கிறேன்! இடது மற்றும் வலது நெடுவரிசைகளில் உள்ள குறியீடு உண்மையில் ஒரே மாதிரியாக உள்ளது. இடதுபுறத்தில் உள்ள குறியீடு ஒரு தனியான செயல்பாட்டைக் கொண்டுள்ளது."

"செயல்பாடு ஒரு குறிப்பிட்ட மதிப்பைக் கணக்கிடுகிறது மற்றும் அந்த மதிப்பை எதை அழைத்தாலும் அதை அனுப்ப திரும்ப அறிக்கையைப் பயன்படுத்துகிறது. குறைந்தபட்சம், நான் அதை எப்படிப் பார்க்கிறேன்."

"நீங்கள் சொல்வது சரிதான்!"

"ஆனால் இந்த வெற்றிட வகை என்ன?"

"சில செயல்பாடுகள் எங்களின் முதன்மை() முறையைப் போன்று எந்த மதிப்பையும் கணக்கிடாமல் அல்லது திரும்பப் பெறாமல் ஏதாவது செய்கின்றன . அத்தகைய செயல்பாடுகளுக்காக ஒரு சிறப்பு திரும்பும் வகை– வெற்றிடத்தை உருவாக்கியது."

"ஒரு செயல்பாடு எதையும் திருப்பித் தரவில்லை என்றால் ஏன் எதையும் அறிவிக்கக்கூடாது?"

"எந்த மாறியை எப்படி அறிவிக்கிறோம் என்பதை நினைவில் கொள்க? வகை மற்றும் பெயர். செயல்பாடுகளுக்கு, ஒரு வகை, பெயர் மற்றும் அடைப்புக்குறிகளை நாங்கள் அறிவிக்கிறோம். அடைப்புக்குறிகளுக்குப் பிறகு ஒரு செயல்பாட்டுப் பெயர் நீங்கள் செயல்பாட்டை எவ்வாறு அழைக்கிறீர்கள்."

"எனவே, செயல்பாடுகளை இரண்டு வகைகளாகப் பிரிப்பதை விட 'வெற்று வகையை' கண்டுபிடிப்பது எளிதாக இருந்ததா - மதிப்புகளை வழங்கும் மற்றும் இல்லாதவை?"

"சரியாக! நீ உண்மையிலேயே புத்திசாலி, என் பையன்."

"வெற்றிட வகையை எவ்வாறு திரும்பப் பெறுவது?"

"நாங்கள் செய்யவில்லை. இது இப்படி வேலை செய்கிறது. ரிட்டர்ன் ஸ்டேட்மென்ட்டை இயக்கும் போது, ​​ஜாவா மெஷின் 'ரிட்டர்ன்' என்ற வார்த்தையின் வலதுபுறத்தில் உள்ள வெளிப்பாட்டின் மதிப்பைக் கணக்கிடுகிறது, இந்த மதிப்பை நினைவகத்தின் ஒரு சிறப்புப் பகுதியில் சேமித்து, உடனடியாக முடிவடைகிறது . செயல்பாடு . செயல்பாட்டை அழைப்பதன் விளைவாக, செயல்பாடு அழைக்கப்பட்ட இடத்தில் சேமிக்கப்பட்ட மதிப்பு பயன்படுத்தப்படுகிறது. நான் முன்பு கொடுத்த எடுத்துக்காட்டில் அதை நீங்கள் பார்க்கலாம்."

"int m = min(a, b) m = m2 ஆக மாற்றப்படும் பகுதியைக் குறிக்கிறீர்களா?"

"ஆம். செயல்பாடு முடிந்ததும், செயல்பாட்டின் திரும்ப மதிப்பு அதன் இடத்தில் எழுதப்பட்டதைப் போல எல்லாம் செயல்படும். இந்த சொற்றொடரை உங்கள் மனதில் மீண்டும் செய்யவும், கடைசி எடுத்துக்காட்டில் உள்ள குறியீட்டைப் பாருங்கள். "

"இது எளிதானது என்று நான் நினைக்கிறேன், இது உண்மையில் கடினம். நான் அதன் சில பகுதிகளை மட்டுமே புரிந்துகொண்டேன்."

"அது சரி. முதல் முயற்சியில் உங்களுக்கு ஏற்கனவே தெரிந்த விஷயங்களை மட்டுமே புரிந்து கொள்ள முடியும் ."

"சரி, நீ சொன்னால். தொடரட்டும்."