இணைப்பதற்கான கோட்பாடுகள்

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

public class Auto {

   public void go() {

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

   public void brake() {

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

   public static void main(String[] args) {

       Auto auto = new Auto();

       // From the user's perspective,

       // one pedal is pressed and the car accelerates.
       auto.gas();

       // The other is pressed, and the car slows down.
       auto.brake();
   }
}

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

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. குறியீடு மாற்றங்கள் பயனர்களை பாதிக்காது. முறைகளில் ஏதேனும் மற்றும் அனைத்து மாற்றங்களையும் நாங்கள் செய்கிறோம். இது முறையின் பயனரைப் பாதிக்காது: எரிவாயு பெடலைப் பயன்படுத்துவதற்கு முன்பு சரியான குறியீடு "auto.gas()" ஆக இருந்தால், அது தொடர்ந்து இருக்கும். வாயு() முறையின் உள்ளே நாம் எதையாவது மாற்றியுள்ளோம் என்பது பயனருக்கு கண்ணுக்கு தெரியாததாகவே உள்ளது: முன்பு போலவே, அழைப்பாளர் விரும்பிய முடிவைப் பெறுகிறார்.