உங்கள் சொந்த முறைகளை உருவாக்குதல் மற்றும் வாதங்களை அனுப்புதல்

1. ஜாவாவில் செயல்பாடுகள்/முறைகள்

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

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

ஆம், மற்றும் முறைகள் (அல்லது செயல்பாடுகள்) இதற்கு எங்களுக்கு உதவும்.

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

உதாரணமாக:

class Solution
{
   public static void main(String[] args)
   {
     System.out.print("Wi-");
     System.out.println("Fi");
     System.out.print("Wi-");
     System.out.println("Fi");

     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

class Solution
{
   public static void main(String[] args)
   {
     printWiFi();
     printWiFi();
     printWiFi();
   }
   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

இடது நெடுவரிசையில் உள்ள நிரலில், நாங்கள் அதே குறியீட்டை மூன்று முறை மீண்டும் செய்கிறோம் - ஒரு புள்ளியை விளக்குவதற்காக வேண்டுமென்றே இதைச் செய்தோம். ஆனால் வலதுபுறத்தில் உள்ள நிரலில், மீண்டும் மீண்டும் வரும் குறியீட்டை ஒரு தனி முறைக்கு நகர்த்தி, அதற்கு ஒரு தனித்துவமான பெயரைக் கொடுத்தோம் — printWiFi.

இடமாற்றப்பட்ட குறியீட்டிற்குப் பதிலாக, printWiFi()முறையை 3 முறை அழைக்கிறோம்.

வலதுபுறத்தில் உள்ள நிரல் நிரலை இயக்கும் போது, ​​​​ஒவ்வொரு முறையும் printWiFi()முறை செயல்படுத்தப்படும் போது, ​​​​அந்த printWiFi()முறையின் அனைத்து கட்டளைகளும் செயல்படுத்தப்படும். பல கட்டளைகளை ஒரு குழுவாக இணைத்து, ஒரு புதிய கட்டளையை (முறை) உருவாக்கினோம்.

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

2. ஜாவாவில் ஒரு முறையை அறிவித்தல்

அப்படியானால், உங்கள் முறையை எவ்வாறு சரியாக எழுதுவது?

public static void name()
{
  method body
}

ஒரு முறையை அறிவிக்கும் போது (உருவாக்கும்) கருத்தில் கொள்ள வேண்டிய நுணுக்கங்கள் ஏராளமாக உள்ளன, ஆனால் நாங்கள் அடிப்படைகளுடன் தொடங்குவோம். எளிமையான முறையை நாம் எவ்வாறு அறிவிக்க முடியும்? ஒரு எளிய முறை அறிவிப்பு இதுபோல் தெரிகிறது:

name முறையின் தனித்துவமான பெயர் எங்கே மற்றும் method bodyமுறையை உருவாக்கும் கட்டளைகளைக் குறிக்கிறது. வார்த்தைகளின் அர்த்தம் public, staticமற்றும் voidபின்னர் விவாதிக்கப்படும்.

நாம் ஒரு முறையை உருவாக்கிய பிறகு, அதை நமது மற்ற முறைகளில் அழைக்கலாம். ஒரு முறை அழைப்பு இது போல் தெரிகிறது:

name();

நாம் அழைக்க விரும்பும் முறையின் தனித்துவமான பெயர் எங்கே name, அதாவது முறை அழைப்பிற்கு வரும்போது அதன் கட்டளைகளை இயக்க விரும்பும் முறை.

நிரல் முறை அழைப்பை அடையும் போது, ​​அது வெறுமனே முறைக்குள் நுழைந்து, அதன் அனைத்து கட்டளைகளையும் செயல்படுத்தி, அசல் முறைக்குத் திரும்பி, தொடர்ந்து செயல்படுத்தும்.

நீங்கள் ஏற்கனவே யூகித்துள்ளபடி, நாங்கள் இதுவரை கற்றுக்கொண்ட பெரும்பாலான கட்டளைகள் மற்ற புரோகிராமர்களால் எங்கள் வாழ்க்கையை எளிதாக்கும் முறைகள்: , , போன்றவை.System.out.println()Thread.sleep()

ஒரு முறை மற்ற முறைகளுக்கான அழைப்புகளைக் கொண்டிருக்கலாம்:

class Solution
{
   public static void main(String[] args)
   {
     printWiFi10Times();
   }

   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }

   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

Wi-Fi

3. முறைகள் பற்றிய உண்மைகள்

முறைகள் பற்றிய மேலும் சில உண்மைகள் இங்கே:

உண்மை 1. ஒரு முறை எப்போதும் ஒரு வகுப்பின் பகுதியாகும்.

ஒரு முறையை ஒரு வகுப்பில் மட்டுமே அறிவிக்க முடியும். ஒரு முறையை மற்றொரு முறைக்குள் அறிவிக்க முடியாது. ஒரு வகுப்பிற்கு வெளியே ஒரு முறையை அறிவிக்க முடியாது.

உண்மை 2. ஒரு முறையின் பெயருக்கு புனிதமான அர்த்தம் இல்லை.

எந்த முறைகள் அழைக்கப்படுகின்றன என்பது முக்கியமல்ல - அது எதையும் பாதிக்காது. முக்கிய முறை மற்ற அனைத்தையும் போலவே ஒரு முறை. ஜாவா இயந்திரம் நிரலை செயல்படுத்தத் தொடங்கும் முறைக்கு இந்த பெயர் தேர்ந்தெடுக்கப்பட்டது. இதில் மந்திரம் எதுவும் இல்லை.

உண்மை 3. ஒரு வகுப்பில் உள்ள முறைகளின் வரிசை முக்கியமில்லை.

உங்கள் முறைகளை எந்த வரிசையிலும் வகுப்பில் எழுதலாம் - இது நிரலின் செயல்பாட்டை எந்த வகையிலும் பாதிக்காது. உதாரணமாக:

class Solution
{
   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }
   
   public static void main(String[] args)
   {
     printWiFi10Times();
   }

   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }
}

class Solution
{
   public static void printWiFi()
   {
     System.out.print("Wi-");
     System.out.println("Fi");
   }

   public static void printWiFi10Times()
   {
     for (int i = 0; i < 10; i++)
       printWiFi();
   }
   public static void main(String[] args)
   {
     printWiFi10Times();
   }
}

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

வேகாஸில் என்ன நடக்கிறது, வேகாஸில் இருக்கும். மற்றும் ஒரு முறைக்குள் அறிவிக்கப்பட்ட மாறிகள் முறைக்குள் இருக்கும்.

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

4. முறை பெயர்கள்

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

உண்மையில், முறைகளை எவ்வாறு சரியாகப் பெயரிடுவது என்பது குறித்து கிட்டத்தட்ட முழு விஞ்ஞானமும் வெளிப்பட்டுள்ளது. ஒவ்வொரு நிரலாக்க மொழிக்கும் அதன் சொந்த தரநிலைகள் உள்ளன. ஜாவாவில், பின்வரும் கொள்கைகளைப் பின்பற்றுவது வழக்கம்:

கொள்கை 1. ஒரு முறையின் பெயர் அந்த முறை என்ன செய்கிறது என்பதை சுருக்கமாக விவரிக்க வேண்டும்.

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

'நிரலை தூங்க வைக்க' பயன்படுத்தப்பட்டது மற்றும் 'அடுத்த முழு எண்ணைப் படிக்க' பயன்படுத்தப்பட்டது என்பதை நினைவில் கொள்க . வசதியானது, இல்லையா?Thread.sleep()Scanner.nextInt()

கொள்கை 2. ஒரு முறையின் பெயர் பல வார்த்தைகளாக இருக்கலாம்.

இருப்பினும், இதைச் செய்யும்போது பல வரம்புகள் உள்ளன:

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

முறையை நினைவுபடுத்துங்கள் printWiFi10Times. அந்த பெயரின் அர்த்தம் என்ன? "வைஃபை' என்ற வார்த்தையை 10 முறை காட்டு". ஒரு முறையின் பெயரில் நீங்கள் நிறைய வார்த்தைகளைச் சேர்க்கக்கூடாது: பெயர் அதன் சாரத்தை பிரதிபலிக்க வேண்டும்.

பெயரிடும் முறைகளுக்கான இந்த தரநிலை கேமல்கேஸ் என்று அழைக்கப்படுகிறது (பெரிய எழுத்துகள் ஒட்டகத்தின் கூம்புகள் போன்றவை).

கொள்கை 3. ஒரு முறையின் பெயர் வினைச்சொல்லுடன் தொடங்குகிறது.

ஒரு முறை எப்போதும் எதையாவது செய்கிறது, எனவே ஒரு முறை பெயரில் உள்ள முதல் சொல் எப்போதும் ஒரு செயலாகும்.

முறைகளுக்கான சில கெட்ட பெயர்கள் இங்கே: home, cat, car, train, ...;

சில நல்ல பெயர்கள்: run, execute, print, read, write, ...

கொள்கை 4. லத்தீன் எழுத்துக்கள் மற்றும் எண்களை மட்டும் பயன்படுத்தவும்.

ஜாவா பல்வேறு மொழிகளுக்கு சிறந்த ஆதரவைக் கொண்டுள்ளது. நீங்கள் மாறிகள், முறைகள் மற்றும் வகுப்புகளின் பெயர்களை ரஷ்ய மற்றும் சீன மொழிகளில் எழுதலாம் - எல்லாம் வேலை செய்யும்!

ஆனாலும்! System.out.println()இந்த முறை சீன மொழியில் எழுதப்பட்டிருந்தால் , ஜாவாவை எவ்வளவு காலம் படிக்க வேண்டும் ? இப்போது விட நீண்ட நேரம், இல்லையா? அதுதான் முதல் புள்ளி.

இரண்டாவதாக, பல மென்பொருள் மேம்பாட்டுக் குழுக்கள் சர்வதேச அளவில் உள்ளன. உலகெங்கிலும் உள்ள புரோகிராமர்களால் மிகப் பெரிய அளவிலான ஜாவா நூலகங்கள் பயன்படுத்தப்படுகின்றன.

எனவே, முறை பெயர்களில் லத்தீன் எழுத்துக்கள் மற்றும் எண்களை மட்டுமே பயன்படுத்த பரிந்துரைக்கப்படுகிறது.