ஜாவாவில் இணைத்தல்

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

இப்போது தகவல்களை மறைப்பது பற்றி பேசலாம்

அவை எவ்வாறு கட்டமைக்கப்பட்டுள்ளன அல்லது அவை எவ்வாறு செயல்படுகின்றன என்பதைப் புரிந்து கொள்ளாமல் அனைத்து வகையான சிக்கலான வழிமுறைகளையும் எவ்வாறு பயன்படுத்துவது? இது எளிதானது: அவற்றின் படைப்பாளிகள் எளிமையான மற்றும் வசதியான இடைமுகங்களை வழங்கினர். ஒரு சோடா இயந்திரத்தில், இடைமுகம் முன் பேனலில் உள்ள பொத்தான்கள் ஆகும். ஒரு பொத்தான் கோப்பையின் அளவைத் தேர்ந்தெடுக்க உங்களை அனுமதிக்கிறது. இரண்டாவது பொத்தானைக் கொண்டு சிரப்பைத் தேர்ந்தெடுக்கவும். பனியைச் சேர்ப்பதற்கு மூன்றில் ஒரு பங்கு பொறுப்பு. நீங்கள் செய்ய வேண்டியது அவ்வளவுதான். இயந்திரம் உள்ளே எப்படி இருக்கிறது என்பது முக்கியமல்ல. முக்கியமான விஷயம் என்னவென்றால், மூன்று பொத்தான்களை அழுத்துவதன் மூலம் பயனர் சோடாவைப் பெறும் வகையில் இது வடிவமைக்கப்பட்டுள்ளது. அதே விஷயம் ஒரு காருக்கும் பொருந்தும். உள்ளே என்ன நடக்கிறது என்பது முக்கியமில்லை. முக்கியமான விஷயம் என்னவென்றால், நீங்கள் வலது மிதியை அழுத்தும்போது கார் முன்னோக்கி நகர்கிறது, இடது மிதியை அழுத்தினால் கார் மெதுவாகிறது. தகவல் மறைத்தலின் சாராம்சம் இதுதான். அனைத்தும் ஒரு திட்டம்' s 'innards' பயனரிடமிருந்து மறைக்கப்பட்டுள்ளது. அத்தகைய தகவல்கள் பயனருக்கு மிதமிஞ்சியவை அல்லது தேவையற்றவை. பயனருக்கு இறுதி முடிவு தேவை, உள் செயல்முறை அல்ல. ஒரு உதாரணத்திற்கு, என்பதை பார்க்கலாம்வாகன வகுப்பு:

public class Vehicle {

   public void gas() {

       /* Some complicated things happen inside a car.
       As a result, it moves forward */
   }

   public void brake() {

       /* Some complicated things happen inside a car.
       As a result, it slows down */
   }

   public static void main(String[] args) {

       Vehicle vehicle = new Vehicle();

       // How everything looks to the user

       // Press one pedal, the car moves
       vehicle.gas();

       // Press the other pedal, the car brakes
       vehicle.brake();
   }
}

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

public class Cat {

   public String name;
   public int age;
   public int weight;

   public Cat(String name, int age, int weight) {
       this.name = name;
       this.age = age;
       this.weight = weight;
   }

   public Cat() {
   }

   public void sayMeow() {
       System.out.println("Meow!");
   }


}

இந்த வகுப்பில் என்ன பிரச்சனை என்று கடந்த பாடம் உங்களுக்கு நினைவிருக்கிறதா? இல்லை என்றால் நினைவு கூர்வோம். பிரச்சனை என்னவென்றால், அதன் தரவு (புலங்கள்) அனைவருக்கும் திறந்திருக்கும். மற்றொரு புரோகிராமர் 0 எடை மற்றும் -1000 வயதுடைய பெயரற்ற பூனையை எளிதாக உருவாக்க முடியும்:

public static void main(String[] args) {

   Cat cat = new Cat();
   cat.name = "";
   cat.age = -1000;
   cat.weight = 0;

}

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

1. அணுகல் மாற்றிகள் ( தனிப்பட்ட, பாதுகாக்கப்பட்ட, தொகுப்பு இயல்புநிலை );
2. பெறுபவர்கள் மற்றும் செட்டர்கள்.

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

இணைத்தல் நமக்கு பல முக்கியமான நன்மைகளை அளிக்கிறது:

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


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


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