OOP கோட்பாடுகள்

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

பொருள் சார்ந்த நிரலாக்கம் (OOP) என்றால் என்ன?

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

Begin
	Class Rectangle (Width, Height); Real Width, Height;
			           
	 Begin
	    Real Area, Perimeter;  
	 
	    Procedure Update;      
	    Begin
	      Area := Width * Height;
              OutText("Rectangle is updating, Area = "); OutFix(Area,2,8); OutImage;
	      Perimeter := 2*(Width + Height);
              OutText("Rectangle is updating, Perimeter = "); OutFix(Perimeter,2,8); OutImage;
	    End of Update;
	 
	    Update;               
	    OutText("Rectangle created: "); OutFix(Width,2,6);
	    OutFix(Height,2,6); OutImage;
	 End of Rectangle;

       Rectangle Class ColouredRectangle (Color); Text Color;
			           
	Begin   	  
	    OutText("ColouredRectangle created, color = "); OutText(Color);
	    OutImage;
        End of ColouredRectangle;

 
      	 Ref(Rectangle) Cr;            
	 Cr :- New ColouredRectangle(10, 20, "Green"); 
End;

இந்தக் குறியீடு மாதிரிக் குறியீடு "சிமுலா - 50 ஆண்டுகள் OOP" என்பதிலிருந்து வீக்லி-கீக்லி மூலம் எடுக்கப்பட்டது. நீங்கள் பார்க்க முடியும் என, ஜாவா அதன் தாத்தாவிலிருந்து மிகவும் வேறுபட்டதல்ல :) சிமுலாவின் தோற்றம் ஒரு புதிய கருத்தாக்கத்தின் பிறப்பைக் குறித்தது: பொருள் சார்ந்த நிரலாக்கம். விக்கிபீடியா ஓஓபியை இப்படி வரையறுக்கிறது: "பொருள்-சார்ந்த நிரலாக்கம் (OOP) என்பது "பொருள்கள்" என்ற கருத்தின் அடிப்படையில் ஒரு நிரலாக்க முன்னுதாரணமாகும், இதில் தரவுகள், புலங்களின் வடிவத்தில் (பெரும்பாலும் பண்புக்கூறுகள் என அழைக்கப்படும்) மற்றும் குறியீடு வடிவத்தில் இருக்கலாம். நடைமுறைகள் (பெரும்பாலும் முறைகள் என அழைக்கப்படும்)." என் கருத்துப்படி, இது ஒரு நல்ல வரையறை. நீங்கள் ஜாவாவைக் கற்க ஆரம்பித்தது நீண்ட காலத்திற்கு முன்பு அல்ல, ஆனால் இந்த வரையறையில் உங்களுக்குத் தெரியாத எந்த வார்த்தைகளும் இல்லை :) இன்று OOP என்பது மிகவும் பொதுவான நிரலாக்க முறை. ஜாவாவைத் தவிர, OOP கொள்கைகள் நீங்கள் கேள்விப்பட்ட பல பிரபலமான மொழிகளில் பயன்படுத்தப்படுகின்றன. எடுத்துக்காட்டாக, C++ (கேம் மேம்பாட்டில் தீவிரமாகப் பயன்படுத்தப்படுகிறது), ஆப்ஜெக்டிவ்-சி மற்றும் ஸ்விஃப்ட் (ஆப்பிள் சாதனங்களுக்கான நிரல்களை எழுதப் பயன்படுகிறது), பைதான் (இயந்திரக் கற்றலில் மிகவும் பிரபலமானது), PHP (மிகவும் பிரபலமான வலை அபிவிருத்தி மொழிகளில் ஒன்று), ஜாவாஸ்கிரிப்ட் ( இது எதற்காகப் பயன்படுத்தப்படவில்லை என்று சொல்வது எளிது) மற்றும் பல. எனவே, OOP இன் கொள்கைகள் என்ன? விரிவாகச் சொல்கிறோம். எப்படியும் OOP இன் கொள்கைகள் என்ன? விரிவாகச் சொல்கிறோம். எப்படியும் OOP இன் கொள்கைகள் என்ன? விரிவாகச் சொல்கிறோம்.

OOP கோட்பாடுகள்

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

கொள்கை 1. பரம்பரை

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

கொள்கை 2. சுருக்கம்

இது மிகவும் எளிமையான கொள்கை. சுருக்கம் என்பது ஒரு விஷயத்தின் முக்கிய, மிக முக்கியமான பண்புகளை அடையாளம் காண்பது, அதே நேரத்தில் சிறிய மற்றும் முக்கியமற்ற எதையும் நிராகரிப்பது. சக்கரத்தை மீண்டும் கண்டுபிடிக்க வேண்டிய அவசியமில்லை. வகுப்புகள் பற்றிய பழைய பாடத்திலிருந்து ஒரு உதாரணத்தை நினைவு கூர்வோம். நிறுவன ஊழியர்களுக்காக ஒரு தாக்கல் முறையை உருவாக்குகிறோம் என்று வைத்துக்கொள்வோம். "பணியாளர்" பொருட்களை உருவாக்க, நாங்கள் ஒரு பணியாளர் வகுப்பை எழுதியுள்ளோம். நிறுவனத்தின் தாக்கல் அமைப்பில் அவற்றை விவரிக்க என்ன பண்புகள் முக்கியம்? பெயர், பிறந்த தேதி, SSN மற்றும் பணியாளர் ஐடி. ஆனால் இந்த வகையான பதிவுக்கு பணியாளரின் உயரம், கண் நிறம் அல்லது முடி நிறம் தேவைப்படுவது சாத்தியமில்லை. ஒரு பணியாளரைப் பற்றிய அத்தகைய தகவல் நிறுவனத்திற்குத் தேவையில்லை. எனவே, பணியாளர் வகுப்பில், பின்வரும் மாறிகளை நாங்கள் அறிவிக்கிறோம்:, முழு வயது , int socialSecurityNumber , மற்றும் intemploymentId . மற்றும் கண் நிறம் போன்ற தேவையற்ற தகவல்களை நாங்கள் சுருக்கிக் கொள்கிறோம். இருப்பினும், ஒரு மாடலிங் ஏஜென்சிக்கான தாக்கல் முறையை நாங்கள் உருவாக்கினால், நிலைமை வியத்தகு முறையில் மாறுகிறது. ஒரு மாடலின் உயரம், கண் நிறம் மற்றும் முடி நிறம் ஆகியவை முக்கியமான குணாதிசயங்கள், ஆனால் அவளுடைய SSN எங்களுக்கு முற்றிலும் பொருத்தமற்றது. எனவே, மாதிரி வகுப்பில், பின்வரும் மாறிகளை உருவாக்குகிறோம்: சரம் உயரம் , சரம் முடி , சரம் கண்கள் .

கொள்கை 3. இணைத்தல்

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

Cat.age = -1000;

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

கொள்கை 4. பாலிமார்பிசம்

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

public class Animal {

   public void speak() {
      
       System.out.println("Hello!");
   }
}

public class Dog extends Animal {
  
   @Override
   public void speak() {
       System.out.println ("Woof-woof!");
   }
}

public class Cat extends Animal {

   @Override
   public void speak() {
       System.out.println("Meow!");
   }
}

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

public class Main {

   public static void main(String[] args) {

       Animal dog = new Dog();
       dog.speak();
   }
}

எந்த முறை என்று நீங்கள் நினைக்கிறீர்கள்? Animal.speak() அல்லது Dog.speak() ? நாய் வகுப்பில் உள்ள முறை அழைக்கப்படும்: வூஃப்-வூஃப்! நாங்கள் ஒரு விலங்கு குறிப்பை உருவாக்கினோம், ஆனால் பொருள் ஒரு நாய் போல் செயல்படுகிறது . தேவைப்பட்டால், அது பூனை, குதிரை அல்லது வேறு சில விலங்குகளைப் போல நடந்து கொள்ளலாம். முக்கிய விஷயம் என்னவென்றால், பொதுவான விலங்கு குறிப்பு மாறிக்கு ஒரு குறிப்பிட்ட துணைப்பிரிவை ஒதுக்குவது . இது அர்த்தமுள்ளதாக இருக்கிறது, ஏனென்றால் எல்லா நாய்களும் விலங்குகள். "பொருட்களின் நடத்தை அவற்றின் வகையைப் பொறுத்து மாறுபடும்" என்று நாங்கள் சொன்னபோது அதைத்தான் நாங்கள் மனதில் வைத்திருந்தோம். நாம் ஒரு பூனை பொருளை உருவாக்கினால் ...

public static void main(String[] args) {

   Animal cat = new Cat();
   cat.speak();
}

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

public class AnimalBarbershop {

   public void trim(Animal animal) {

       System.out.println("The haircut is done!"); 
   }
}

இப்போது நாம் பூனை மற்றும் நாய் பொருட்களை டிரிம்() முறைக்கு அனுப்பலாம்!

public static void main(String[] args) {

   Cat cat = new Cat();
   Dog dog = new Dog();

   AnimalBarbershop barbershop = new AnimalBarbershop();

   barbershop.trim(cat);
   barbershop.trim(dog);
}

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

நமக்கு ஏன் OOP தேவை?

ஏன் OOP ஒரு புதிய நிரலாக்கக் கருத்தாக எழுந்தது? புரோகிராமர்கள் செயல்முறை மொழிகள் போன்ற செயல்படும் கருவிகளைக் கொண்டிருந்தனர். அடிப்படையில் புதிதாக ஒன்றைக் கண்டுபிடிக்க அவர்களைத் தூண்டியது எது? எல்லாவற்றிற்கும் மேலாக, அவர்கள் எதிர்கொள்ளும் பணிகளின் சிக்கலானது. 60 ஆண்டுகளுக்கு முன்பு ப்ரோக்ராமரின் பணியானது "சில கணித வெளிப்பாட்டை மதிப்பிடுவது" போல இருந்தால், இப்போது அது "ஸ்டால்கர் விளையாட்டிற்கு 7 வெவ்வேறு முடிவுகளை செயல்படுத்துவது போல இருக்கலாம், இது A, B, C, DE புள்ளிகளில் எடுக்கப்பட்ட வீரர்களின் முடிவுகளின் கலவையைப் பொறுத்து. , மற்றும் விளையாட்டில் எஃப்." நீங்கள் பார்க்க முடியும் என, கடந்த தசாப்தங்களில் பணிகள் மிகவும் சிக்கலானதாகிவிட்டன. இதன் விளைவாக, தரவு வகைகள் மிகவும் சிக்கலானதாகிவிட்டன. OOP தோன்றியதற்கு இது மற்றொரு காரணம். ஒரு கணித வெளிப்பாட்டை சாதாரண பழமையானவற்றைப் பயன்படுத்தி எளிதாக மதிப்பீடு செய்யலாம். இங்கு பொருள்கள் தேவையில்லை. ஆனால் தனிப்பயன் வகுப்புகளைப் பயன்படுத்தாமல் விளையாட்டு முடிவுகளுடன் கூடிய பணி விவரிக்க கடினமாக இருக்கும். வகுப்புகள் மற்றும் பொருள்களைப் பயன்படுத்தி அதை விவரிப்பது மிகவும் எளிதானது என்று கூறினார். வெளிப்படையாக, எங்களுக்கு பல வகுப்புகள் தேவைப்படும்: கேம், ஸ்டாக்கர், எண்டிங், பிளேயர் டெசிஷன், கேம் ஈவென்ட் மற்றும் பல. வேறு வார்த்தைகளில் கூறுவதானால், சிக்கலைத் தீர்க்கத் தொடங்காமல், நம் தலையில் ஒரு தீர்வை எளிதாக "வரைந்து" முடியும். பணிகளின் அதிகரித்து வரும் சிக்கலானது புரோகிராமர்களை பகுதிகளாக பிரிக்க கட்டாயப்படுத்தியது. ஆனால் செயல்முறை நிரலாக்கத்தில் இதைச் செய்வது அவ்வளவு எளிதானது அல்ல. மேலும் பெரும்பாலும் ஒரு நிரல் ஒரு மரத்தைப் போல நிறைய கிளைகளைக் கொண்டு சாத்தியமான அனைத்து செயல்படுத்தல் பாதைகளையும் குறிக்கும். சில நிபந்தனைகளைப் பொறுத்து, நிரலின் ஒரு கிளை அல்லது மற்றொன்று செயல்படுத்தப்பட்டது. சிறிய நிரல்களுக்கு, இது வசதியானது, ஆனால் ஒரு பெரிய சிக்கலை பகுதிகளாகப் பிரிப்பது மிகவும் கடினமாக இருந்தது. OOP தோன்றுவதற்கு இது மற்றொரு காரணமாகும். இந்த முன்னுதாரணம் புரோகிராமர்களுக்கு ஒரு நிரலை "தொகுதிகள்" (வகுப்புகள்) என்ற தொகுப்பாகப் பிரிக்கும் திறனை வழங்கியது, அவை ஒவ்வொன்றும் அதன் சொந்த வேலையைச் செய்கின்றன. ஒருவருக்கொருவர் தொடர்புகொள்வதன் மூலம், அனைத்து பொருட்களும் எங்கள் நிரலின் வேலையை நிறைவேற்றுகின்றன. கூடுதலாக, நிரலில் வேறு இடங்களில் எங்கள் குறியீட்டை மீண்டும் பயன்படுத்தலாம், இது நிறைய நேரத்தை மிச்சப்படுத்துகிறது.