இடைமுகங்களில் இயல்புநிலை முறைகள்

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

public interface Car {

   public void gas();
  
   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void go() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void go() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

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

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

இப்போது அனைத்து கார்களுக்கும் ஒரே மாதிரியாக இருந்த gas()முறைகள் brake(), இடைமுகத்திற்கு நகர்த்தப்பட்டு, நகல் குறியீட்டின் தேவையை நீக்குகிறது. மற்றும் முறைகள் ஒவ்வொரு வகுப்புகளிலும் கிடைக்கின்றன!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

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

public class UnusualCar implements Car {
   @Override
   public void go() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car slows down differently!");
   }
}

மற்ற 99 வகையான கார்களும் இயல்புநிலை முறையைப் பயன்படுத்தும்UnusualCarவகுப்பு ஒரு விதிவிலக்கு. பெரிய படத்தை கெடுக்காமல், அது தனது சொந்த நடத்தையை அமைதியாக வரையறுக்கும். இடைமுகங்களில் பல பரம்பரை. உங்களுக்கு ஏற்கனவே தெரியும், ஜாவாவில் மல்டிபிள் ஹெரிடென்ஸ் இல்லை. இதற்கு பல காரணங்கள் உள்ளன. அவற்றை ஒரு தனி பாடத்தில் விரிவாகக் கருதுவோம். C++ போன்ற பிற மொழிகளில் நிலைமை தலைகீழாக உள்ளது. ஒரே பொருள் பல்வேறு குணாதிசயங்கள் மற்றும் நடத்தைகளைக் கொண்டிருப்பதால், பல மரபுகள் ஒரு தீவிர சவாலை அளிக்காது. உதாரணமாக, நாம் நம் பெற்றோருக்கு குழந்தைகள், எங்கள் ஆசிரியர்களுக்கு மாணவர்கள், நம் மருத்துவர்களுக்கு நோயாளிகள். நிஜ வாழ்க்கையில், நாங்கள் பல்வேறு பாத்திரங்களை நிரப்புகிறோம், அதன்படி, வித்தியாசமாக நடந்துகொள்கிறோம்: வெளிப்படையாக, நெருங்கிய நண்பர்களை விட ஆசிரியர்களுடன் வித்தியாசமாக தொடர்பு கொள்கிறோம். இந்த சூழ்நிலையை குறியீட்டில் மொழிபெயர்க்க முயற்சிப்போம். எங்களிடம் இரண்டு வகுப்புகள் இருப்பதாக கற்பனை செய்து கொள்வோம்: குளம் மற்றும் பறவைகள். ஒரு குளத்திற்கு நீச்சல் பறவைகள் தேவை, ஒரு பறவைக் கூடத்திற்கு பறக்கும் பறவைகள் தேவை. இதைப் பிரதிநிதித்துவப்படுத்த, நாங்கள் இரண்டு அடிப்படை வகுப்புகளை உருவாக்கினோம்:FlyingBirdமற்றும் Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

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

public class Duck implements FlyingBird, Waterfowl {

   // Methods of both interfaces combine easily into one class
  
   @Override
   public void fly() {
       System.out.println("Flying!");
   }

   @Override
   public void swim() {

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

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