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 అనేది అత్యంత సాధారణ ప్రోగ్రామింగ్ పద్దతి. జావాతో పాటు, OOP సూత్రాలు మీరు విన్న అనేక ప్రసిద్ధ భాషలలో ఉపయోగించబడతాయి. ఉదాహరణకు, C++ (గేమ్ డెవలప్‌మెంట్‌లో చురుకుగా ఉపయోగించబడుతుంది), ఆబ్జెక్టివ్-C మరియు స్విఫ్ట్ (ఆపిల్ పరికరాల కోసం ప్రోగ్రామ్‌లను వ్రాయడానికి ఉపయోగిస్తారు), పైథాన్ (మెషీన్ లెర్నింగ్‌లో అత్యంత ప్రజాదరణ పొందినది), PHP (అత్యంత జనాదరణ పొందిన వెబ్ అభివృద్ధి భాషలలో ఒకటి), జావాస్క్రిప్ట్ ( ఇది దేనికి ఉపయోగించబడదని చెప్పడం సులభం) మరియు అనేక ఇతరాలు. కాబట్టి, OOP యొక్క సూత్రాలు ఏమిటి? మేము మీకు వివరంగా చెబుతాము. ఏమైనప్పటికీ OOP యొక్క సూత్రాలు ఏమిటి? మేము మీకు వివరంగా చెబుతాము. ఏమైనప్పటికీ OOP యొక్క సూత్రాలు ఏమిటి? మేము మీకు వివరంగా చెబుతాము.

OOP సూత్రాలు

ఇవి పునాదికి పునాది. ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ నమూనాను రూపొందించే 4 ప్రధాన లక్షణాలు. విజయవంతమైన ప్రోగ్రామర్‌గా మారడానికి వాటిని అర్థం చేసుకోవడం చాలా అవసరం.

సూత్రం 1. వారసత్వం

శుభవార్త: OOP యొక్క కొన్ని సూత్రాలు మీకు ఇప్పటికే తెలుసు! :) మేము ఇప్పటికే పాఠాలలో రెండు సార్లు వారసత్వాన్ని ఎదుర్కొన్నాము మరియు మేము దానిని ఉపయోగించగలిగాము. వారసత్వం అనేది ఇప్పటికే ఉన్న (తల్లిదండ్రుల) తరగతి ఆధారంగా కొత్త తరగతిని వివరించడానికి మిమ్మల్ని అనుమతించే మెకానిజం. అలా చేయడం ద్వారా, కొత్త తరగతి మాతృ తరగతి యొక్క లక్షణాలు మరియు కార్యాచరణను తీసుకుంటుంది. వారసత్వం అంటే ఏమిటి మరియు అది ఏ ప్రయోజనాలను అందిస్తుంది? అన్నింటికంటే, కోడ్ పునర్వినియోగం. మాతృ తరగతులలో ప్రకటించిన ఫీల్డ్‌లు మరియు పద్ధతులను సంతతి తరగతులలో ఉపయోగించవచ్చు. అన్ని రకాల కార్లు 10 సాధారణ ఫీల్డ్‌లు మరియు 5 ఒకే విధమైన పద్ధతులను కలిగి ఉంటే, మీరు వాటిని ఆటోలోకి తరలించాలిమాతృ తరగతి. మీరు వాటిని ఎటువంటి సమస్యలు లేకుండా సంతతి తరగతులలో ఉపయోగించవచ్చు. ఘన ప్రయోజనాలు: పరిమాణాత్మక (తక్కువ కోడ్) మరియు, ఫలితంగా, గుణాత్మక (తరగతులు చాలా సరళంగా మారతాయి). అంతేకాకుండా, వారసత్వం చాలా అనువైనది - మీరు వారసులు తప్పిపోయిన ప్రత్యేక కార్యాచరణను వ్రాయవచ్చు (కొన్ని ఫీల్డ్‌లు లేదా నిర్దిష్ట తరగతికి సంబంధించిన ప్రవర్తన). సాధారణంగా, నిజ జీవితంలో, మనమందరం మా తల్లిదండ్రులతో కొంతవరకు సమానంగా ఉంటాము, కానీ వారి నుండి ఏదో ఒకవిధంగా భిన్నంగా ఉంటాము :)

సూత్రం 2. సంగ్రహణ

ఇది చాలా సులభమైన సూత్రం. నైరూప్యత అంటే ఏదైనా ఒకదాని యొక్క ప్రధానమైన, అత్యంత ముఖ్యమైన లక్షణాలను గుర్తించడం, అదే సమయంలో చిన్నవి మరియు అమూల్యమైన వాటిని విస్మరించడం. చక్రం తిరిగి ఆవిష్కరించాల్సిన అవసరం లేదు. తరగతుల గురించి పాత పాఠం నుండి ఒక ఉదాహరణను గుర్తుకు తెచ్చుకుందాం. మేము కంపెనీ ఉద్యోగుల కోసం ఫైలింగ్ సిస్టమ్‌ను రూపొందిస్తున్నామని అనుకుందాం. "ఉద్యోగి" వస్తువులను సృష్టించడానికి, మేము ఉద్యోగి తరగతిని వ్రాసాము. కంపెనీ ఫైలింగ్ సిస్టమ్‌లో వాటిని వివరించడానికి ఏ లక్షణాలు ముఖ్యమైనవి? పేరు, పుట్టిన తేదీ, SSN మరియు ఉద్యోగి ID. కానీ ఈ రకమైన రికార్డ్ కోసం మాకు ఉద్యోగి ఎత్తు, కంటి రంగు లేదా జుట్టు రంగు అవసరమయ్యే అవకాశం లేదు. ఉద్యోగి గురించి కంపెనీకి అలాంటి సమాచారం అవసరం లేదు. కాబట్టి, ఉద్యోగి తరగతిలో, మేము ఈ క్రింది వేరియబుల్స్‌ను ప్రకటిస్తాము:, పూర్ణాంక వయస్సు , పూర్ణాంక సామాజిక భద్రత సంఖ్య మరియు పూర్ణాంక ఉద్యోగి ఐడి . మరియు మేము కంటి రంగు వంటి అనవసరమైన సమాచారాన్ని సంగ్రహిస్తాము. అయితే, మేము మోడలింగ్ ఏజెన్సీ కోసం ఫైలింగ్ సిస్టమ్‌ను రూపొందిస్తున్నట్లయితే, పరిస్థితి ఒక్కసారిగా మారుతుంది. మోడల్ యొక్క ఎత్తు, కంటి రంగు మరియు జుట్టు రంగు ముఖ్యమైన లక్షణాలు, కానీ ఆమె 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 సంవత్సరాల క్రితం ప్రోగ్రామర్ యొక్క పని "కొన్ని గణిత వ్యక్తీకరణలను మూల్యాంకనం చేయడం" లాంటిది అయితే, ఇప్పుడు అది "A, B, C, DE పాయింట్ల వద్ద ప్లేయర్ యొక్క నిర్ణయాల కలయికపై ఆధారపడి, STALKER గేమ్ కోసం 7 వేర్వేరు ముగింపులను అమలు చేయడం లాంటిది కావచ్చు. , మరియు గేమ్‌లో F." మీరు గమనిస్తే, గత దశాబ్దాలుగా పనులు మరింత క్లిష్టంగా మారాయి. మరియు ఫలితంగా, డేటా రకాలు మరింత క్లిష్టంగా మారాయి. OOP కనిపించడానికి ఇది మరొక కారణం. సాధారణ ఆదిమాంశాలను ఉపయోగించి గణిత వ్యక్తీకరణను సులభంగా అంచనా వేయవచ్చు. ఇక్కడ ఏ వస్తువులు అవసరం లేదు. కానీ కస్టమ్ తరగతులను ఉపయోగించకుండా గేమ్ ముగింపులతో కూడిన పనిని వివరించడం కూడా కష్టం. తరగతులు మరియు వస్తువులను ఉపయోగించి దానిని వివరించడం చాలా సులభం అని పేర్కొంది. సహజంగానే, మాకు అనేక తరగతులు అవసరం: గేమ్, స్టాకర్, ఎండింగ్, ప్లేయర్ డెసిషన్, గేమ్ ఈవెంట్ మరియు మొదలైనవి. మరో మాటలో చెప్పాలంటే, సమస్యను పరిష్కరించడానికి ప్రారంభించకుండానే, మన తలపై పరిష్కారాన్ని సులభంగా "స్కెచ్" చేయవచ్చు. టాస్క్‌ల యొక్క పెరుగుతున్న సంక్లిష్టత ప్రోగ్రామర్లు వాటిని భాగాలుగా విభజించవలసి వచ్చింది. కానీ విధానపరమైన ప్రోగ్రామింగ్‌లో దీన్ని చేయడం అంత సులభం కాదు. మరియు చాలా తరచుగా ప్రోగ్రామ్ అనేది అన్ని సాధ్యమైన అమలు మార్గాలను సూచించే అనేక శాఖలతో చెట్టులా ఉంటుంది. కొన్ని షరతులపై ఆధారపడి, ప్రోగ్రామ్ యొక్క ఒక శాఖ లేదా మరొకటి అమలు చేయబడింది. చిన్న ప్రోగ్రామ్‌ల కోసం, ఇది సౌకర్యవంతంగా ఉంటుంది, కానీ పెద్ద సమస్యను భాగాలుగా విభజించడం చాలా కష్టం. OOP ఆవిర్భావానికి ఇది మరో కారణం. ఈ ఉదాహరణ ప్రోగ్రామర్‌లకు ప్రోగ్రామ్‌ను "మాడ్యూల్స్" (తరగతులు) సమూహంగా విభజించే సామర్థ్యాన్ని అందించింది, వీటిలో ప్రతి ఒక్కటి దాని స్వంత పనిని చేస్తుంది. ఒకదానితో ఒకటి పరస్పర చర్య చేయడం ద్వారా, అన్ని వస్తువులు మా ప్రోగ్రామ్ యొక్క పనిని పూర్తి చేస్తాయి. అదనంగా, మేము ప్రోగ్రామ్‌లో మరెక్కడైనా మా కోడ్‌ను మళ్లీ ఉపయోగించవచ్చు, ఇది చాలా సమయాన్ని కూడా ఆదా చేస్తుంది.