முறை அறிவிப்பு

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

முறை அறிவிப்பு

ஒரு முறையை வரையறுக்கும் அனைத்து குறியீடுகளும் முறை அறிவிப்பு எனப்படும் . ஒரு முறை அறிவிப்பின் பொதுவான வடிவத்தை பின்வருமாறு விவரிக்கலாம்:

access modifier, return type, method name (parameter list) {
    // method body
}

எடுத்துக்காட்டுகளாக, வகுப்பின் பல்வேறு முறைகளின் அறிவிப்புகளைப் பாருங்கள் Dog.

public class Dog {

   String name;

   public Dog(String name) {
       this.name = name;
   }

   public static void main(String[] args) {
       Dog max = new Dog("Max");
       max.woof();

   }

   public void woof() {
       System.out.println("A dog named " + name + " says \"Woof, woof!\"");
   }

   public void run(int distanceInFeet) {
       System.out.println("A dog named " + name + " ran " + distanceInFeet + " feet!");
   }

   public String getName() {
       return name;
   }
}

1. அணுகல் மாற்றி

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

public class Main {

   public static void main(String[] args) {

       Dog butch = new Dog("Butch");
       butch.run(100);
   }

}

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

2. நிலையான முக்கிய சொல்

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

3. மதிப்பு மதிப்பு

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

public String getName() {
   return name;
}

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

public void woof() {
   System.out.println("A dog named " + name + " says \"Woof, woof!\"");
}

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

ஒரு முறையை அழைக்க பல்வேறு வழிகளில் நாங்கள் விரும்பும் சூழ்நிலைகள் உள்ளன. ஏன் நமது சொந்த செயற்கை நுண்ணறிவை உருவாக்கக்கூடாது? அமேசானில் அலெக்சா உள்ளது, ஆப்பிளில் சிரி உள்ளது, அப்படியானால் நாம் ஏன் அதை வைத்திருக்கக்கூடாது? :) அயர்ன் மேன் திரைப்படத்தில், டோனி ஸ்டார்க் தனது சொந்த நம்பமுடியாத செயற்கை நுண்ணறிவை உருவாக்குகிறார், ஜார்விஸ். அந்த அற்புதமான கதாபாத்திரத்திற்கு அஞ்சலி செலுத்துவோம் மற்றும் அவரது நினைவாக நமது AI க்கு பெயரிடுவோம். :) நாம் செய்ய வேண்டிய முதல் விஷயம், ஜார்விஸுக்கு அறைக்குள் நுழையும் நபர்களுக்கு ஹலோ சொல்ல கற்றுக்கொடுப்பதுதான் (இப்படிப்பட்ட அற்புதமான புத்தி அநாகரீகமாக மாறினால் அது விசித்திரமாக இருக்கும்).

public class Jarvis {

   public void sayHi(String name) {
       System.out.println("Good evening, " + name + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
   }
}

கன்சோல் வெளியீடு: மாலை வணக்கம், டோனி ஸ்டார்க். எப்படி இருக்கிறீர்கள்? மிகவும் நல்லது! ஜார்விஸ் இப்போது விருந்தினர்களை வரவேற்க முடிகிறது. நிச்சயமாக, அதை விட அடிக்கடி அவரது மாஸ்டர், டோனி ஸ்டார்க். ஆனால் அவர் மட்டும் வரவில்லை என்றால் என்ன! ஆனால் எங்கள் sayHi()முறை ஒரு வாதத்தை மட்டுமே ஏற்றுக்கொள்கிறது. அதனால் அது அறைக்குள் நுழையும் ஒருவரை மட்டுமே வரவேற்கும், மற்றவரை புறக்கணிக்கும். மிகவும் கண்ணியமாக இல்லை, ஒப்புக்கொண்டீர்களா? :/ இந்த விஷயத்தில், ஒரே பெயரில் 2 முறைகளை எழுதுவதன் மூலம் சிக்கலை தீர்க்க முடியும், ஆனால் வெவ்வேறு அளவுருக்கள்:

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

}

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

public class Jarvis {

   public void sayHi(String firstGuest) {
       System.out.println("Good evening, " + firstGuest + ". How are you?");
   }

   public void sayHi(String firstGuest, String secondGuest) {
       System.out.println("Good evening, " + firstGuest + " and " + secondGuest + ". How are you?");
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

கன்சோல் வெளியீடு: மாலை வணக்கம், டோனி ஸ்டார்க். எப்படி இருக்கிறீர்கள்? மாலை வணக்கம், டோனி ஸ்டார்க் மற்றும் கேப்டன் அமெரிக்கா. எப்படி இருக்கிறீர்கள்? அருமை, இரண்டு பதிப்புகளும் வேலை செய்தன. :) ஆனால் நாங்கள் சிக்கலை தீர்க்கவில்லை! மூன்று விருந்தினர்கள் இருந்தால் என்ன செய்வது? நிச்சயமாக, இந்த முறையை மீண்டும் ஓவர்லோட் செய்யலாம் sayHi(), இதனால் அது மூன்று விருந்தினர் பெயர்களை ஏற்கும். ஆனால் 4 அல்லது 5 இருக்கலாம். முடிவிலிக்கு அனைத்து வழிகளும். sayHi()ஒரு மில்லியன் முறை () முறையை ஓவர்லோட் செய்யாமல், எத்தனை பெயர்களையும் கையாள ஜார்விஸுக்குக் கற்றுக்கொடுக்க சிறந்த வழி இல்லையா ? :/ நிச்சயமாக இருக்கிறது! இல்லையென்றால், ஜாவா உலகின் மிகவும் பிரபலமான நிரலாக்க மொழியாக இருக்கும் என்று நினைக்கிறீர்களா? ;)

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark");
       System.out.println();
       jarvis.sayHi("Tony Stark", "Captain America");
   }
}

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

public class Jarvis {

   public void sayHi(String...names) {

       for (String name: names) {
           System.out.println("Good evening, " + name + ". How are you?");
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.sayHi("Tony Stark", "Captain America", "Black Widow", "Hulk");
   }
}

கன்சோல் வெளியீடு: மாலை வணக்கம், டோனி ஸ்டார்க். எப்படி இருக்கிறீர்கள்? மாலை வணக்கம், கேப்டன் அமெரிக்கா. எப்படி இருக்கிறீர்கள்? மாலை வணக்கம், கருப்பு விதவை. எப்படி இருக்கிறீர்கள்? மாலை வணக்கம், ஹல்க். எப்படி இருக்கிறீர்கள்? முறையின் உள்ளே, அனைத்து வாதங்களையும் மீண்டும் மீண்டும் செய்கிறோம் மற்றும் பெயர்களுடன் வடிவமைக்கப்பட்ட சொற்றொடர்களைக் காண்பிக்கிறோம். இங்கே நாம் ஒரு எளிமையான for-eachவளையத்தைப் பயன்படுத்துகிறோம் (இது நீங்கள் முன்பு பார்த்தது). இது இங்கே சரியானது, ஏனென்றால் ( சரம்... பெயர்கள் ) குறியீடானது, கம்பைலர் அனைத்து அனுப்பப்பட்ட வாதங்களையும் ஒரு வரிசையில் வைக்கிறது. இதன் விளைவாக, நாம் மாறி பெயர்களுடன் வேலை செய்யலாம்நாம் ஒரு வரிசையுடன் வேலை செய்வோம், அதை ஒரு சுழற்சியில் மீண்டும் செய்வது உட்பட. கூடுதலாக, இது கடந்து செல்லும் எத்தனை சரங்களுடன் வேலை செய்யும்! இரண்டு, பத்து, ஆயிரம் கூட - இந்த முறை எத்தனை விருந்தினர்களுடனும் சரியாக வேலை செய்யும். எல்லா சாத்தியக்கூறுகளுக்கும் முறையை ஓவர்லோட் செய்வதை விட மிகவும் வசதியானது, நீங்கள் நினைக்கவில்லையா? :) முறை ஓவர்லோடிங்கின் மற்றொரு உதாரணம் இங்கே. ஜார்விஸுக்கு ஒரு முறையைக் கொடுப்போம் printInfoFromDatabase(). இது ஒரு தரவுத்தளத்திலிருந்து ஒரு நபரைப் பற்றிய தகவலைக் காண்பிக்கும். ஒரு நபர் ஒரு சூப்பர் ஹீரோ அல்லது சூப்பர்வில்லன் என்று தரவுத்தளத்தில் குறிப்பிடப்பட்டால், அந்த தகவலை நாங்கள் காண்பிப்போம்:

public class Jarvis {

   public void printInfoFromDatabase (String bio) {

       System.out.println(bio);
   }

   public void printInfoFromDatabase(String bio, boolean isEvil, String nickname) {

       System.out.println(bio);
       if (!isEvil) {
           System.out.println("Also known as the superhero " + nickname);
       } else {
           System.out.println("Also known as the supervillain " + nickname);
       }
   }

   public static void main(String[] args) {
       Jarvis jarvis = new Jarvis();
       jarvis.printInfoFromDatabase("Laura Palmer. Date of birth: July 22, 1972. Twin Peaks, Washington");
       System.out.println();
       jarvis.printInfoFromDatabase("Max Eisenhardt. Height: 15.6 ft. Weight: 189 lbs. ", true, "Magneto");
   }
}

வெளியீடு: லாரா பால்மர். பிறந்த தேதி: ஜூலை 22, 1972. ட்வின் பீக்ஸ், வாஷிங்டன் மேக்ஸ் ஐசன்ஹார்ட். உயரம்: 15.6 அடி. எடை: 189 பவுண்ட். சூப்பர்வில்லன் மேக்னெட்டோ என்றும் அறியப்படுகிறது , எங்கள் முறையின் நடத்தை நாம் அதற்கு அனுப்பும் தரவைப் பொறுத்தது. இங்கே மற்றொரு முக்கியமான விஷயம்: வாதங்களின் வரிசை முக்கியமானது! எங்கள் முறை ஒரு சரத்தையும் எண்ணையும் எடுக்கும் என்று வைத்துக்கொள்வோம்:

public class Person {

   public static void sayYourAge(String greeting, int age) {
       System.out.println(greeting + " " + age);
   }

   public static void main(String[] args) {

       sayYourAge("My age is ", 33);
       sayYourAge(33, "My age is "); // Error!
   }
}

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

ஒத்த அளவுருக்கள் கொண்ட முறைகளை எவ்வாறு அழைப்பது

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

public class Person {

   public void introduce(String name, String age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person alex = new Person();
       alex.introduce ("Alex", "twenty-one");

       Person mary = new Person();
       mary.introduce("Mary", 32);
   }
}

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

public static void main(String[] args) {

   Person victor = new Person();
   victor.introduce("Victor", null);// Ambiguous method call!
}

தொகுத்தல் பிழையைப் பெறுவோம்! இதற்கு என்ன காரணம் மற்றும் "தெளிவின்மை" என்றால் என்ன? உண்மையில், எல்லாம் மிகவும் எளிமையானது. பிரச்சனை என்னவென்றால், இந்த முறையின் இரண்டு பதிப்புகள் எங்களிடம் உள்ளன: ஒன்று Stringஇரண்டாவது வாதமாக, மற்றும் ஒன்று Integerஇரண்டாவது வாதமாக உள்ளது. ஆனால் ஒரு Stringமற்றும் ஒரு Integerஇரண்டு இருக்க முடியும் null! அவை குறிப்பு வகைகளாக இருப்பதால், nullஇவை இரண்டின் இயல்புநிலை மதிப்பு. அதனால்தான் இந்த சூழ்நிலையில் கம்பைலர் எந்த முறையின் பதிப்பை அழைக்க வேண்டும் என்பதைக் கண்டுபிடிக்க முடியாது. இந்த பிரச்சனைக்கான தீர்வு மிகவும் எளிமையானது. Nullஒரு குறிப்பிட்ட குறிப்பு வகைக்கு வெளிப்படையாக மாற்றலாம். எனவே, நீங்கள் ஒரு முறையை அழைக்கும்போது, ​​இரண்டாவது வாதத்திற்கு நீங்கள் விரும்பும் தரவு வகையை அடைப்புக்குறிக்குள் குறிப்பிடலாம்! கம்பைலர் உங்கள் "குறிப்பை" புரிந்துகொண்டு சரியான முறையை அழைக்கும்:

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, Integer age) {
       System.out.println("Method with a string and a number!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", (String) null);
   }
}

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

public class Person {

   public void introduce(String name, String age) {
       System.out.println("Method with two strings!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public void introduce(String name, int age) {
       System.out.println("Method with a string and a number!!");
       System.out.println("My name is " + name + ". My age is " + age);
   }

   public static void main(String[] args) {

       Person victor = new Person();
       victor.introduce("Victor", null);
   }
}

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