இடைமுகங்களின் சாராம்சம்

1. திறன்கள்

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

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

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

interface CanMove
{
   void move(String newLocation);
}

interface Rideable
{
   void ride(Passenger passenger);
}

interface CanTransport
{
   void addStuff(Object stuff);
   Object removeStuff();
}

class Wheel implements CanMove
{
   ...
}

class Car implements CanMove, Rideable, CanTransport
{
   ...
}

class Skateboard implements CanMove, Rideable
{
   ...
}

2. பாத்திரங்கள்

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

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

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

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

interface CanSpeak
{
   void speak();
}

class Cat implements CanSpeak
{
   void speak()
   {
      println("MEOW");
   }
}

class Dog implements CanSpeak
{
   void speak()
   {
      println("WOOF");
   }
}

class Fish
{
   ...
}

public static void main(String[] args)
{
   // Add all the animals to the list
   ArrayList pets = new ArrayList();
   pets.add(new Cat());
   pets.add(new Dog());
   pets.add(new Fish());

   // If the ability exists, then make a sound
   for(Object pet: pets)
   {
      if (pet instanceof CanSpeak)
      {
         CanSpeak loudmouth = (CanSpeak) pet;
         loudmouth.speak();
      }
   }
}

உங்கள் திட்டங்களில் உள்ள வகுப்புகளின் எண்ணிக்கை ஆயிரங்களை எட்டும்போது, ​​இடைமுகங்கள் இல்லாமல் உங்களால் வாழ முடியாது. ஆயிரக்கணக்கான வகுப்புகளின் தொடர்புகளை விவரிப்பதற்குப் பதிலாக, சில டஜன் இடைமுகங்களின் தொடர்புகளை விவரிப்பது போதுமானது - இது வாழ்க்கையை பெரிதும் எளிதாக்குகிறது.

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

3. defaultஇடைமுக முறைகளை செயல்படுத்துதல்

சுருக்க வகுப்புகள் மாறிகள் மற்றும் முறைகளின் செயலாக்கங்களைக் கொண்டிருக்கலாம், ஆனால் அவை பல மரபுரிமைகளைக் கொண்டிருக்க முடியாது. இடைமுகங்கள் மாறிகள் அல்லது முறைகளின் செயலாக்கங்களைக் கொண்டிருக்க முடியாது, ஆனால் அது பல பரம்பரைகளைக் கொண்டிருக்கலாம்.

நிலைமை பின்வரும் அட்டவணையில் வெளிப்படுத்தப்பட்டுள்ளது:

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

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

புதுப்பிக்கப்பட்ட அட்டவணை இதோ (JDK 8 மற்றும் அதற்கு மேல்):

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

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

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

பிரச்சனை

முறைகளைக் கொண்ட இடைமுகங்களைப் பயன்படுத்துவது பெரிய வகுப்பு படிநிலைகளை பெரிதும் எளிதாக்கும். எடுத்துக்காட்டாக, சுருக்கம் InputStreamமற்றும் OutputStreamவகுப்புகள் இடைமுகங்களாக அறிவிக்கப்படலாம்! இது அவற்றை அடிக்கடி மற்றும் மிகவும் வசதியாக பயன்படுத்த அனுமதிக்கிறது.

ஆனால் உலகில் ஏற்கனவே கோடிக்கணக்கான (பில்லியன்கள்?) ஜாவா வகுப்புகள் உள்ளன. நீங்கள் நிலையான நூலகங்களை மாற்றத் தொடங்கினால், நீங்கள் எதையாவது உடைக்கலாம். எல்லாம் போல! 😛

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

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

interface Pet
{
   default void meow()
   {
      System.out.println("Meow");
   }
}

interface Cat extends Pet
{
   void meow(); // Here we override the default implementation by omitting an implementation
}

class Tom implements Cat
{
}

Tomவகுப்பானது முறையைச் செயல்படுத்தாததால் குறியீடு தொகுக்கப்படாது meow().