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

கோட்ஜிம் பல்கலைக்கழகப் பாடத்தின் ஒரு பகுதியாக வழிகாட்டியுடன் விரிவுரைத் துணுக்கு. முழு பாடத்திற்கும் பதிவு செய்யவும்.

"அமிகோ, நீங்கள் ஏற்கனவே இங்கு இருக்கிறீர்களா? நீங்கள் ஏற்கனவே நிறைய ஜாவா கட்டளைகளைக் கற்றுக்கொண்டீர்கள் என்று எனக்குத் தெரியும். நீங்கள் கிட்டத்தட்ட எனது நிலையை அடைந்துவிட்டீர்கள்!"

"அது உண்மையா, டியாகோ?"

"நிச்சயமாக இல்லை, ஹா-ஹா. உங்களுக்கு இன்னும் நிறைய படிப்பது மற்றும் செய்ய கற்றுக்கொள்வது உள்ளது. இன்னும், உங்களுக்கு மிகவும் சிக்கலான நிரல்களை எழுத போதுமான அளவு ஏற்கனவே தெரியும். ஒரு நிரலில் 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()முறையின் உள்ளே உள்ள அனைத்து கட்டளைகளும் செயல்படுத்தப்படும். நாங்கள் ஒரு புதிய கட்டளையை (முறை) உருவாக்கி, பல கட்டளைகளை ஒரே குழுவாக இணைத்தோம்.

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

"ஒரு நிரலை முறைகளாகப் பிரிப்பது ஒரு சிறந்த யோசனை.

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

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

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

"எளிய முறையை நாம் எப்படி அறிவிக்க முடியும்? எப்படி என்பது இங்கே:

public static void name()
{
  method body
}

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

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

name();

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

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

"இப்போது, ​​அமிகோ, நீங்கள் ஏற்கனவே கற்றுக்கொண்ட கட்டளைகளை புதிய கண்களுடன் பாருங்கள். உதாரணமாக, . இது உண்மையில் என்ன என்பது பற்றி ஏதாவது நினைவுக்கு வருகிறதா?"System.out.println()

"இந்த கட்டளைகள் அனைத்தும் மற்ற புரோகிராமர்களால் எழுதப்பட்ட முறைகள் என்று நீங்கள் கூறுகிறீர்களா?"

"எல்லோரும் இல்லை, ஆனால் அவர்களில் பலர். ஆம், சரியாக! மற்றவர்கள் நம் வாழ்க்கையை எளிதாக்குவதற்காக அவற்றை எழுதினார்கள்."

"அதுவும் public static void main(String[] args)ஒரு முறைதான்... இப்போது அது இன்னும் அர்த்தமுள்ளதாக இருக்கிறது!"

"நிச்சயமாக, அது செய்கிறது! இது நிரலாக்கம்! முக்கிய முறை - நிரலின் ஆல்பா மற்றும் ஒமேகா - மற்ற முறைகளுக்கான அழைப்புகளைக் கொண்டிருக்கலாம்:

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

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

"உங்களுக்கான முறைகள் பற்றிய சில பயனுள்ள உண்மைகளை நான் ஒதுக்கியுள்ளேன். இங்கே, மகிழுங்கள்:

உண்மை 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. ஒரு முறையின் உள்ளே இருக்கும் மாறிகள் மற்ற முறைகளின் மாறிகளுடன் எந்த வகையிலும் தொடர்புடையவை அல்ல

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

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

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

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

"இது மிகவும் கடினம் என்று நான் நினைக்கவில்லை!"

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

"ஜாவாவில், இந்தக் கொள்கைகளைப் பின்பற்றுவது வழக்கம்:

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

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

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

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

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

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

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

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

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

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

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

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

கொள்கை 4. ஒரு முறையின் பெயர் லத்தீன் எழுத்துக்கள் மற்றும் எண்களை மட்டுமே பயன்படுத்துகிறது.

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

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

இப்போது விட நீண்டது, இல்லையா? அதுதான் முதல் புள்ளி.

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

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

முக்கியமான:

ஒரு முறையின் பெயர் ஒரு எழுத்தில் தொடங்க வேண்டும் (அது ஒரு எண்ணுடன் தொடங்க முடியாது).

"இவை அனைத்தும் ஜாவாவில் முறை பெயரிடுவதைக் கட்டுப்படுத்தும் அடிப்படைக் கோட்பாடுகள். பாடம் இப்போது முடிந்துவிட்டது. பணிகளைத் தீர்க்கச் செல்லுங்கள்!"

"நான் ஏற்கனவே ஓடிக்கொண்டிருக்கிறேன், டியாகோ!"

கோட்ஜிம் பல்கலைக்கழகப் பாடத்தின் ஒரு பகுதியாக வழிகாட்டியுடன் விரிவுரைத் துணுக்கு. முழு பாடத்திற்கும் பதிவு செய்யவும்.