జావాలో పాలిమార్ఫిజం

హాయ్! ఈ రోజు మనం OOP సూత్రాలపై పాఠాల శ్రేణిని ముగించాము. ఈ పాఠంలో, మేము జావా పాలిమార్ఫిజం గురించి మాట్లాడుతాము. పాలిమార్ఫిజం అనేది అనేక రకాలైన వాటితో ఒకే రకంగా పని చేసే సామర్ధ్యం. అంతేకాకుండా, వస్తువుల ప్రవర్తన వాటి రకాన్ని బట్టి భిన్నంగా ఉంటుంది. ఈ ప్రకటనను నిశితంగా పరిశీలిద్దాం. మొదటి భాగంతో ప్రారంభిద్దాం: 'అనేక రకాలతో ఒకే రకంగా పని చేయగల సామర్థ్యం'. వివిధ రకాలు ఒకేలా ఎలా ఉంటాయి? ఇది కొంచెం వింతగా అనిపిస్తుంది :/ నిజానికి, ఇదంతా చాలా సులభం. ఉదాహరణకు, వారసత్వం యొక్క సాధారణ ఉపయోగం సమయంలో ఈ పరిస్థితి తలెత్తుతుంది. అది ఎలా పని చేస్తుందో చూద్దాం. ఒకే రన్() పద్ధతితో మనకు సాధారణ క్యాట్ పేరెంట్ క్లాస్ ఉందని అనుకుందాం :

public class Cat {

   public void run() {
       System.out.println("Run!");
   }
}

ఇప్పుడు మేము పిల్లిని వారసత్వంగా పొందే మూడు తరగతులను సృష్టిస్తాము : సింహం , పులి మరియు చిరుత .

public class Lion extends Cat {

   @Override
   public void run() {
       System.out.println("Lion runs at 80 km/h");
   }
}

public class Tiger extends Cat {

   @Override
   public void run() {
       System.out.println("Tiger runs at 60 km/h");
   }
}

public class Cheetah extends Cat {

   @Override
   public void run() {
       System.out.println("Cheetah runs at up to 120 km/h");
   }
}

కాబట్టి మాకు 3 తరగతులు ఉన్నాయి. వాళ్ళు ఒకే క్లాస్ అన్నట్టు వాళ్ళతో కలిసి పని చేసే పరిస్థితిని మోడల్ చేద్దాం. మా పిల్లులలో ఒకటి అనారోగ్యంతో ఉందని మరియు డాక్టర్ డోలిటిల్ నుండి సహాయం అవసరమని ఊహించండి. సింహాలు, పులులు మరియు చిరుతలను నయం చేయగల డోలిటిల్ క్లాస్‌ని రూపొందించడానికి ప్రయత్నిద్దాం .

public class Dolittle {

   public void healLion(Lion lion) {

       System.out.println("Lion is healthy!");
   }

   public void healTiger(Tiger tiger) {

       System.out.println("Tiger is healthy!");
   }

   public void healCheetah(Cheetah cheetah) {

       System.out.println("Cheetah is healthy!");
   }
}

సమస్య పరిష్కరించబడినట్లు కనిపిస్తోంది: తరగతి వ్రాయబడింది మరియు వెళ్ళడానికి సిద్ధంగా ఉంది. కానీ మేము మా కార్యక్రమాన్ని పొడిగించాలనుకుంటే మనం ఏమి చేస్తాము? మన దగ్గర ప్రస్తుతం 3 రకాలు మాత్రమే ఉన్నాయి: సింహాలు, పులులు మరియు చిరుతలు. కానీ ప్రపంచంలో 40 కంటే ఎక్కువ రకాల పిల్లులు ఉన్నాయి. మేము మాన్యుల్స్, జాగ్వర్లు, మైనే కూన్స్, ఇంటి పిల్లులు మరియు మిగిలిన అన్నింటికి ప్రత్యేక తరగతులను జోడిస్తే ఏమి జరుగుతుందో ఊహించండి. ప్రోగ్రామ్ దానంతట అదే పని చేస్తుంది, అయితే ప్రతి రకమైన పిల్లిని నయం చేయడానికి మేము నిరంతరం డోలిటిల్ తరగతికి కొత్త పద్ధతులను జోడించాలి. ఫలితంగా, ఇది అపూర్వమైన పరిమాణాలకు పెరుగుతుంది. ఇక్కడే పాలిమార్ఫిజం - "అవి ఒకే రకంగా ఉన్నట్లుగా అనేక రకాలతో పని చేయగల సామర్థ్యం" - వస్తుంది. మనం అదే పనిని చేయడానికి లెక్కలేనన్ని పద్ధతులను సృష్టించాల్సిన అవసరం లేదు - పిల్లిని నయం చేస్తుంది. వారందరికీ ఒక పద్ధతి సరిపోతుంది:

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
   }
}

హీల్‌క్యాట్ () పద్ధతి సింహం , పులి మరియు చిరుత వస్తువులను అంగీకరించగలదు - అవన్నీ పిల్లి యొక్క ఉదాహరణలు :

public class Main {

   public static void main(String[] args) {

       Dolittle dolittle = new Dolittle();

       Lion simba = new Lion();
       Tiger shereKhan = new Tiger();
       Cheetah chester = new Cheetah();

       dolittle.healCat(simba);
       dolittle.healCat(shereKhan);
       dolittle.healCat(chester);
   }
}

కన్సోల్ అవుట్‌పుట్: రోగి ఆరోగ్యంగా ఉన్నాడు! రోగి ఆరోగ్యంగా ఉన్నాడు! రోగి ఆరోగ్యంగా ఉన్నాడు! కాబట్టి మా డోలిటిల్తరగతి వివిధ రకాలుగా ఒకే రకంగా పనిచేస్తుంది. ఇప్పుడు రెండవ భాగాన్ని పరిష్కరిద్దాం: "అంతేకాకుండా, వస్తువుల ప్రవర్తన వాటి రకాన్ని బట్టి భిన్నంగా ఉంటుంది". ఇది అన్ని చాలా సులభం. ప్రకృతిలో, ప్రతి పిల్లి ఒక్కో విధంగా నడుస్తుంది. కనిష్టంగా, అవి వేర్వేరు వేగంతో నడుస్తాయి. మా మూడు పిల్లి జాతులలో, చిరుత అత్యంత వేగవంతమైనది, అయితే పులి మరియు సింహం నెమ్మదిగా పరిగెత్తుతాయి. మరో మాటలో చెప్పాలంటే, వారి ప్రవర్తన భిన్నంగా ఉంటుంది. పాలీమార్ఫిజం వివిధ రకాలను ఒకటిగా ఉపయోగించడం కంటే ఎక్కువ చేస్తుంది. ఇది వారి వ్యత్యాసాలను గుర్తుంచుకోవడానికి అనుమతిస్తుంది, వాటిలో ప్రతిదానికి ప్రత్యేకమైన ప్రవర్తనను సంరక్షిస్తుంది. కింది ఉదాహరణ దీనిని వివరిస్తుంది. మా పిల్లులు, విజయవంతంగా కోలుకున్న తర్వాత, కొద్దిగా పరుగును ఆస్వాదించాలని నిర్ణయించుకున్నాయని అనుకుందాం. మేము దీన్ని మా డోలిటిల్ తరగతికి జోడిస్తాము :

public class Dolittle {

   public void healCat(Cat cat) {

       System.out.println("The patient is healthy!");
       cat.run();
   }
}

మూడు జంతువులకు చికిత్స చేయడానికి ఒకే కోడ్‌ని అమలు చేయడానికి ప్రయత్నిద్దాం:

public static void main(String[] args) {

   Dolittle dolittle = new Dolittle();

   Lion simba = new Lion();
   Tiger shereKhan = new Tiger();
   Cheetah chester = new Cheetah();

   dolittle.healCat(simba);
   dolittle.healCat(shereKhan);
   dolittle.healCat(chester);
}

మరియు ఫలితాలు ఎలా ఉంటాయో ఇక్కడ ఉంది: రోగి ఆరోగ్యంగా ఉన్నాడు! సింహం గంటకు 80 కిమీ వేగంతో పరుగెత్తుతుంది. రోగి ఆరోగ్యంగా ఉన్నాడు! టైగర్ గంటకు 60 కిమీ వేగంతో పరిగెడుతుంది. రోగి ఆరోగ్యంగా ఉన్నాడు! చిరుత 120 km/h వేగంతో పరిగెడుతుంది, ఇక్కడ మనం వస్తువుల యొక్క నిర్దిష్ట ప్రవర్తన భద్రపరచబడిందని మనం స్పష్టంగా చూస్తాము, అయినప్పటికీ మేము మూడు జంతువులను పిల్లికి 'సాధారణీకరించిన' తర్వాత పద్ధతికి పంపాము . పాలీమార్ఫిజం కారణంగా, ఇవి కేవలం మూడు పిల్లులు కాదని జావా బాగా గుర్తుపెట్టుకుంది. అవి సింహం, పులి మరియు చిరుత, ఒక్కొక్కటి ఒక్కో విధంగా నడుస్తాయి. ఇది పాలిమార్ఫిజం యొక్క ప్రధాన ప్రయోజనాన్ని వివరిస్తుంది: వశ్యత. అనేక రకాలుగా భాగస్వామ్యం చేయబడిన కొన్ని కార్యాచరణలను మనం అమలు చేయవలసి వచ్చినప్పుడు, సింహాలు, పులులు మరియు చిరుతలు కేవలం 'పిల్లులు' అవుతాయి. అన్ని జంతువులు విభిన్నంగా ఉంటాయి, కానీ కొన్ని సందర్భాల్లో పిల్లి దాని జాతులతో సంబంధం లేకుండా పిల్లిలా ఉంటుంది :) మీ కోసం ఇక్కడ కొన్ని వీడియో నిర్ధారణ ఉంది. ఈ 'సాధారణీకరణ' అవాంఛనీయమైనప్పుడు మరియు ప్రతి జాతి భిన్నంగా ప్రవర్తించాల్సిన అవసరం వచ్చినప్పుడు, ప్రతి రకం దాని స్వంత పనిని చేస్తుంది. పాలిమార్ఫిజమ్‌కు ధన్యవాదాలు, మీరు విస్తృత శ్రేణి తరగతుల కోసం ఒకే ఇంటర్‌ఫేస్ (పద్ధతుల సమితి) సృష్టించవచ్చు. ఇది ప్రోగ్రామ్‌లను తక్కువ క్లిష్టతరం చేస్తుంది. మేము 40 రకాల పిల్లులకు మద్దతు ఇవ్వడానికి ప్రోగ్రామ్‌ను విస్తరించినప్పటికీ, మేము ఇప్పటికీ సరళమైన ఇంటర్‌ఫేస్‌ను కలిగి ఉంటాము: మొత్తం 40 పిల్లులకు ఒకే రన్() పద్ధతి.