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

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

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 gas() {
       System.out.println("Gas!");
   }

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


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

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

"உங்கள் கருத்துப்படி, இந்தக் குறியீட்டின் முக்கிய பிரச்சனை என்ன? நாங்கள் மீண்டும் மீண்டும் குறியீடுகளை எழுதியிருப்பதை நீங்கள் கவனித்திருக்கலாம்! இந்த சிக்கல் நிரலாக்கத்தில் பொதுவானது, நீங்கள் அதைத் தவிர்க்க வேண்டும். இதற்கு முன் குறிப்பிட்ட தீர்வுகள் இல்லை என்பது வேறு விஷயம். Java 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 gas() {
       System.out.println("This car accelerates differently!");
   }

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

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

public class Waterfowl {
}

public class FlyingBird {
}

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

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

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

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