ஜாவாவில் முறை அளவுருக்கள்

1. வாதங்களை அனுப்புதல்

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

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

public static void name(parameters)
{
  method body
}

name முறையின் தனித்துவமான பெயர் எங்கே மற்றும் method body முறையை உருவாக்கும் கட்டளைகளைக் குறிக்கிறது. மேலும் parameters இது காற்புள்ளிகளால் பிரிக்கப்பட்ட முறை அளவுருக்களுக்கான ஒதுக்கிடமாகும். இந்த டெம்ப்ளேட்டை இன்னும் விரிவாக விவரிப்போம்:

public static void name(Type1 name1, Type2 name2, Type3 name3)
{
  method body
}

எடுத்துக்காட்டுகள்:

public static void print(String str)
{
}

public static void print(String str, int count)
{
}

public static void write(int x, int y)
{
}

முறை அளவுருக்களைக் கொண்டிருக்க விரும்பவில்லை எனில், அடைப்புக்குறிகளை காலியாக விடுவோம்.

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

எடுத்துக்காட்டாக, குறிப்பிட்ட எண்ணிக்கையிலான முறை உரையின் சரத்தைக் காண்பிக்கும் முறையை எழுதுவோம்.

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

இதைச் செய்யும் குறியீடு இப்படி இருக்கும்:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

ஒவ்வொரு முறையும் ஒரு முறை அழைக்கப்படும்போது, ​​அதன் அளவுருக்கள் அனுப்பப்பட்ட மதிப்புகள் ஒதுக்கப்படும், அதன் பிறகுதான் நாம் முறையின் உள்ளே கட்டளைகளை இயக்கத் தொடங்குகிறோம்.

2. வாதங்கள்

அளவுருக்கள் கொண்ட ஒரு முறையை அழைப்பதில் உங்கள் கவனத்தை இன்னும் கொஞ்சம் ஈர்க்க விரும்புகிறேன்.

முறைக்கு அனுப்பப்பட்ட மதிப்புகள் பொதுவாக முறைக்கு அனுப்பப்படும் போது அவை வாதங்கள் என்று அழைக்கப்படுகின்றன.

மற்றொரு உதாரணத்தைப் பார்ப்போம்:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.println(text);
   }

   public static void main(String[] args)
   {
     printLines("Hi", 10);
     printLines("Bye", 20);
   }
}

முறை printLines முதல் முறையாக அழைக்கப்பட்டபோது, ​​அதன் அளவுருக்கள் பின்வரும் மதிப்புகள் ஒதுக்கப்பட்டன:
String text = "Hi", int count = 10.

முறை printLinesஇரண்டாவது முறையாக அழைக்கப்பட்டபோது, ​​அதன் அளவுருக்கள் வெவ்வேறு மதிப்புகள் ஒதுக்கப்பட்டன
String text = "Bye", int count = 20:

ஒரு முறை அழைக்கப்படும் போது குறிப்பிட்ட மதிப்புகள் ஒதுக்கப்படும் மாறிகளை விட அளவுருக்கள் அதிகமாகவும் குறைவாகவும் இல்லை. மதிப்புகள் "Hi", "Bye", 10மற்றும் 20அவையே வாதங்கள் என்று அழைக்கப்படுகின்றன."

3. ஒரு முறையை அழைக்கும் போது முரண்பட்ட மாறி பெயர்கள்

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

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String str = "Hi";
     int n = 10;
     printLines(str, n);
   }
}

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

இப்போது நமது மாறிகளை இந்த முறையில் மறுபெயரிடுவோம் main:

class Solution
{
   public static void printLines(String text, int count)
   {
     for (int i = 0; i < count; i++)
       System.out.print(text);
   }

   public static void main(String[] args)
   {
     String text = "Hi";
     int count = 10;
     printLines(text, count);
   }
}

இரண்டு விஷயங்களில் கவனம் செலுத்துங்கள்

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

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

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

4. முறைகளுக்கான குறிப்புகளை அனுப்புதல்

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

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

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

இந்த மாறிகளில் ஒன்று முறை அளவுருவாக இருந்தால் என்ன நடக்கும்?

class Solution
{
   public static void printArraySum(int[] data)
   {
     int sum = 0;
     for (int i = 0; i < data.length; i++)
       sum = sum + data[i];
     System.out.println(sum);
   }
   
   public static void main(String[] args)
   {
     int[] months = {31, 28, 31, 30, 31, 30, 31, 31, 30};
     printArraySum(months);
   }
}

சரியாக அதே விஷயம் நடக்கும்: data அளவுருவில் மாறியின் அதே பகுதி நினைவகத்தின் குறிப்பைக் கொண்டிருக்கும் months. முறை அழைக்கப்படும் போது, ​​ஒரு எளிய பணி ஏற்படுகிறது :data = months

மேலும் இரண்டு மாறிகளும் ஒரு முழு எண்ணைச் சேமிக்கும் நினைவகத்தின் ஒரே பகுதியைக் குறிப்பதால், இந்த printArraySum முறையானது வரிசையிலிருந்து மதிப்புகளைப் படிப்பது மட்டுமல்லாமல், அவற்றை மாற்றவும் முடியும்!

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

class Solution
{
   public static void fill(int[][] data, int value)
   {
     for (int i = 0; i < data.length; i++)
     {
       for (int j = 0; j < data[i].length; j++)
         data[i][j] = value;
     }
  }

   public static void main(String[] args)
   {
     int[][] months = {{31, 28}, {31, 30, 31}, {30, 31, 31}};
     fill (months, 8);
   }
}

5. அதே பெயரைக் கொண்ட முறைகள்

இப்போது முறை பெயர்களுக்கு மீண்டும் வருவோம்.

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

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

void fill(int[] data, int value) {
}
void fill(int[][] data, int value) {
}
void fill(int[][][] data, int value)  {
}

void print(String str) {
}
void print(String str, String str2) {
}
void print(int val) {
}
void print(double val) {
}
void print() {
}

void sum(int x, int y) {
}
void sum(int data, int value) {
}

சில முறைகள் ஏன் ஒரே மாதிரியாகக் கருதப்படுகின்றன , மற்றவை வேறுபட்டவை ? ஒரு முறையின் தனித்துவத்தை தீர்மானிக்கும் போது ஏன் அளவுரு பெயர்கள் கணக்கில் எடுத்துக்கொள்ளப்படவில்லை?

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

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

ஆனால் நீங்கள் எழுதினால் , கம்பைலர் முறைக்கான அழைப்பை அளவுருவுடன் பார்க்கும் .System.out.println(1.0)println()double

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

ஒரு முறையின் பெயர் மற்றும் அதன் அளவுருக்களின் வகைகள் முறை கையொப்பம் என்று அழைக்கப்படுகின்றன . உதாரணத்திற்கு,sum(int, int)

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