முறை மீறுதல்

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

public class Animal {
  
   public void speak() {

       System.out.println("Hello!");
   }
}

நாங்கள் எங்கள் திட்டத்தை எழுதத் தொடங்கினாலும், நீங்கள் ஒரு சாத்தியமான சிக்கலைக் காணலாம்: உலகம் நிறைய விலங்குகளால் நிரம்பியுள்ளது, மேலும் அவை அனைத்தும் வித்தியாசமாக "பேசுகின்றன": பூனைகள் மியாவ், வாத்துகள், பாம்புகள் ஹிஸ் போன்றவை. எங்கள் இலக்கு எளிதானது: நாங்கள் பேசுவதற்கு பல முறைகளை உருவாக்குவதை தவிர்க்க வேண்டும். meow()மியாவ், ஹிஸ்ஸிங் போன்றவற்றுக்கு ஒரு முறையை உருவாக்குவதற்குப் பதிலாக , முறை என்று அழைக்கப்படும்போது hiss()பாம்பு சீறவும், பூனை மியாவ் செய்யவும், நாய் குரைக்கவும் விரும்புகிறோம் . முறை மேலெழுதலைப்speak() பயன்படுத்தி இதை நாம் எளிதாக அடையலாம் . விக்கிபீடியா இந்த வார்த்தையை பின்வருமாறு விளக்குகிறது: முறை மேலெழுதுதல், பொருள் சார்ந்த நிரலாக்கத்தில், ஒரு மொழி அம்சமாகும், இது ஒரு துணைப்பிரிவு அல்லது குழந்தை வகுப்பை அதன் சூப்பர்கிளாஸ்கள் அல்லது பெற்றோர் வகுப்புகளில் ஒன்று ஏற்கனவே வழங்கிய ஒரு முறையை ஒரு குறிப்பிட்ட செயல்படுத்தலை வழங்க அனுமதிக்கிறது. அது அடிப்படையில் சரியானது. மேலெழுதுதல், பெற்றோர் வகுப்பின் சில முறையை எடுத்து ஒவ்வொரு பெறப்பட்ட வகுப்பிலும் உங்கள் சொந்த செயலாக்கத்தை எழுத உதவுகிறது. குழந்தை வகுப்பில் புதிய செயல்படுத்தல் பெற்றோரில் உள்ளதை "மாற்றுகிறது". ஒரு உதாரணத்துடன் இது எப்படி இருக்கிறது என்று பார்ப்போம். எங்கள் வகுப்பின் 4 வழித்தோன்றல்களை உருவாக்குவோம் Animal:

public class Bear extends Animal {
   @Override
   public void speak() {
       System.out.println("Growl!");
   }
}
public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

public class Dog extends Animal {

   @Override
   public void speak() {
       System.out.println("Woof!");
   }
}


public class Snake extends Animal {

   @Override
   public void speak() {
       System.out.println("Hiss!");
   }
}

எதிர்காலத்திற்கான ஒரு சிறிய லைஃப்ஹேக்: பெற்றோர் வகுப்பின் முறைகளை மேலெழுத, IntelliJ IDE இல் உள்ள பெறப்பட்ட வகுப்பின் குறியீட்டிற்குச் சென்று , Ctrl+O ஐ அழுத்தி , மெனுவிலிருந்து மேலெழுத்து முறைகள்... என்பதைத் தேர்ந்தெடுக்கவும். ஆரம்பத்திலிருந்தே ஹாட்கிகளைப் பயன்படுத்தப் பழகிக் கொள்ளுங்கள். அவர்கள் குறியீட்டை வேகப்படுத்துவார்கள்! விரும்பிய நடத்தையைப் பெற, நாங்கள் சில விஷயங்களைச் செய்தோம்:

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

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

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

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

public class Main {

   public static void main(String[] args) {

       Animal animal1 = new Dog();
       Animal animal2 = new Cat();
       Animal animal3 = new Bear();
       Animal animal4 = new Snake();
      
       animal1.speak();
       animal2.speak();
       animal3.speak();
       animal4.speak();
   }
}

கன்சோல் வெளியீடு:

Woof! 
Meow! 
Growl! 
Hiss!

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

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

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

   
   public class Animal {
   
      public void speak(String s) {
   
          System.out.println("Speaking: " + s);
      }
   }
   
   public class Cat extends Animal {
   
      @Override // Error!
      public void speak() {
          System.out.println("Meow!");
      }
   }
   




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

   இல்லையெனில், தொகுத்தல் பிழையைப் பெறுவோம்:

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   
   public class Cat extends Animal {
   
      @Override
      public String speak() {         // Error!
          System.out.println("Meow!");
          return "Meow!";
      }
   }
   




3. மேலெழுதப்பட்ட முறையின் அணுகல் மாற்றியும் அசல் ஒன்றிலிருந்து வேறுபட முடியாது:

   
   public class Animal {
   
      public void speak() {
   
          System.out.println("Hello!");
      }
   }
   
   public class Cat extends Animal {
   
      @Override
      private void speak() {      // Error!
          System.out.println("Meow!");
      }
   }
   

ஜாவாவில், பாலிமார்பிஸத்தை செயல்படுத்த முறை மேலெழுதுதல் என்பது ஒரு வழியாகும். அதாவது அதன் முக்கிய நன்மை நாம் முன்பு பேசிய அந்த நெகிழ்வுத்தன்மை. வகுப்புகளின் எளிய மற்றும் தர்க்கரீதியான படிநிலையை நாம் உருவாக்க முடியும், ஒவ்வொன்றும் குறிப்பிட்ட நடத்தை (குரைக்கும் நாய்கள், பூனைகள் பூனைகள்) ஆனால் ஒரு இடைமுகம் - வெவ்வேறு speak()முறைகளின் தொகுப்பைக் காட்டிலும் அனைவருக்கும் ஒரே முறை, எ.கா. bark(), meow()போன்றவை.