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

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

"நீ என் ஆர்வத்தைத் தூண்டிவிட்டாய், டியாகோ... ஒரு புதிய தலைப்பு?"

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

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

வாதங்கள்

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

நமது உதாரணத்தை இன்னொரு முறை பார்க்கலாம்:

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அவை வாதங்கள் என்று அழைக்கப்படுகின்றன."

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

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

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

"சரி, அது அர்த்தமுள்ளதாக இருக்கிறது!"

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

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";
     String n = 10;
     printLines(str, n);
   }
}

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

"நல்லது, நல்லது. இப்போது நமது மாறிகளை இந்த முறையில் மறுபெயரிடுவோம் 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";
     String count = 10;
     printLines(text, count);
   }
}

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

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

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

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

"இப்போது எனக்குத் தெரியும்."

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

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

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

"ஒரு டெவலப்பர் ஒரு வரிசை மாறிக்கு மற்றொரு அணி மாறியை ஒதுக்கும்போது, ​​என்ன நடக்கும்?"

"அவர்கள் அதே முகவரியைக் குறிப்பிடுகிறார்களா?"

"சரி. இரண்டு மாறிகள் நினைவகத்தில் ஒரே இடத்தைக் குறிக்கத் தொடங்குகின்றன:

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

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

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

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

"எனக்கு புரிகிறது என்று நினைக்கிறேன், ஆனால் எனக்கு இன்னும் உதாரணங்கள் தேவை!"

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

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

அதே பெயரில் முறைகள்

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

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

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

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

"இப்போது - உன்னிப்பாகக் கவனிக்கவும்! ஒரு வகுப்பில் உள்ள முறைகள் உண்மையில் ஒரே மாதிரியான பெயர்களைக் கொண்டிருக்கலாம்! ஆனால் இந்த விஷயத்தில், அவை வெவ்வேறு அளவுருக்களைக் கொண்டிருக்க வேண்டும். வேறுவிதமாகக் கூறினால், முறைகள் ஒற்றுமைக்காக ஒப்பிடப்படுகின்றன, பெயர்கள் கணக்கில் எடுத்துக்கொள்ளப்படுவது மட்டுமல்லாமல் , அளவுருக்களின் வகைகள் ! _

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()StringSystem.out.println(1.0)println()double

ஆஹா, அது கடந்து செல்லத் தொடங்குகிறது!

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

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

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

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

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