ஜாவாவில் செயல்படுத்துகிறது

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

இடைமுகம் மற்றும் செயல்படுத்தல் என்றால் என்ன

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

public interface MyInterface  {

     // constants declaration 
     // methods without implementation
     // static methods
     // default methods (default)
     // private methods
}

ஜாவாவில் இம்ப்ளிமென்ட்களின் தொடரியல் இங்கே :

public class MyClass implements MyInterface{
//implementing the methods of MyInterface 
//Other code
} 

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

முக்கிய சொல் உதாரணத்தை செயல்படுத்தவும்

public interface Swimmable {
  
   void moveForward();
   void TurnRight();
   void TurnLeft();
  
}

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

public class Duck implements Swimmable {
//implementing the methods
   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

}

public class Fish implements Swimmable {

   public void moveForward() {
       System.out.println("I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft() {
       System.out.println("I am turning left...");
   }

   public void turnUp(){
       System.out.println("I am turning up...");
   }

   public void turnDown(){
       System.out.println("I am turning down...");
   }

   public void Stop() {
       System.out.println("I am relaxing somewhere under the water surface...");
   }
}

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

ஜாவாவில் பல இடைமுகங்கள்

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

To implement multiple interfaces, use the next syntax: 
interface MyFirstInterface {
   public void myMethod();
}
interface MySecondInterface {
   public void myOtherMethod();
}

// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
   public void myMethod() {
      //method implementation
   }
   public void myOtherMethod() {
     //method implementation
   }
}

பல இடைமுகங்களின் எடுத்துக்காட்டு

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

public interface Flyable {
   double startAge = 0.1;
   void fly();
}

public class Duck implements Swimmable, Flyable {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

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