ఇంటర్‌ఫేస్‌ల సారాంశం

1. సామర్ధ్యాలు

ఇంటర్‌ఫేస్‌ల ప్రయోజనాలను మరియు వాటిని ఎక్కడ ఉపయోగించాలో బాగా అర్థం చేసుకోవడానికి, మనం మరికొన్ని వియుక్త విషయాల గురించి మాట్లాడాలి.

ఒక తరగతి సాధారణంగా నిర్దిష్ట వస్తువును మోడల్ చేస్తుంది. ఇంటర్‌ఫేస్ వస్తువులకు తక్కువగా ఉంటుంది మరియు వాటి సామర్థ్యాలు లేదా పాత్రలకు ఎక్కువ అనుగుణంగా ఉంటుంది.

ఉదాహరణకు, కార్లు, బైక్‌లు, మోటార్‌సైకిళ్లు మరియు చక్రాలు వంటివి తరగతులు మరియు వస్తువులుగా ఉత్తమంగా సూచించబడతాయి. కానీ వారి సామర్థ్యాలు - "నేను రైడ్ చేయగలను", "నేను వ్యక్తులను రవాణా చేయగలను", "నేను నిలబడగలను" వంటి వాటిని ఇంటర్‌ఫేస్‌లుగా ప్రదర్శించడం మంచిది. ఇవి కొన్ని ఉదాహరణలు:

interface CanMove
{
   void move(String newLocation);
}

interface Rideable
{
   void ride(Passenger passenger);
}

interface CanTransport
{
   void addStuff(Object stuff);
   Object removeStuff();
}

class Wheel implements CanMove
{
   ...
}

class Car implements CanMove, Rideable, CanTransport
{
   ...
}

class Skateboard implements CanMove, Rideable
{
   ...
}

2. పాత్రలు

ఇంటర్‌ఫేస్‌లు ప్రోగ్రామర్ జీవితాన్ని చాలా సులభతరం చేస్తాయి. చాలా తరచుగా, ప్రోగ్రామ్‌లో వేలకొద్దీ వస్తువులు, వందలకొద్దీ తరగతులు ఉంటాయి, కానీ కేవలం రెండు డజను ఇంటర్‌ఫేస్‌లు , అంటే పాత్రలు . కొన్ని పాత్రలు ఉన్నాయి, కానీ వాటిని (తరగతులు) కలపడానికి అనేక మార్గాలు ఉన్నాయి.

మొత్తం విషయం ఏమిటంటే, మీరు ప్రతి ఇతర తరగతితో పరస్పర చర్య చేయడానికి ప్రతి తరగతికి కోడ్‌ను వ్రాయవలసిన అవసరం లేదు. మీరు వారి పాత్రలతో (ఇంటర్‌ఫేస్‌లు) ఇంటరాక్ట్ అవ్వాలి.

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

అవి ఎలాంటి జంతువు లేదా వాటికి ఎలాంటి ఇతర సామర్థ్యాలు ఉన్నాయో మీరు పట్టించుకోరు. వారు ట్రిపుల్ బ్యాక్ సోమర్సాల్ట్ చేయగలరు కూడా. ఈ ప్రత్యేక సమయంలో, మీరు బిగ్గరగా మాట్లాడే వారి సామర్థ్యంపై మాత్రమే ఆసక్తి కలిగి ఉంటారు. కోడ్‌లో ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:

interface CanSpeak
{
   void speak();
}

class Cat implements CanSpeak
{
   void speak()
   {
      println("MEOW");
   }
}

class Dog implements CanSpeak
{
   void speak()
   {
      println("WOOF");
   }
}

class Fish
{
   ...
}

public static void main(String[] args)
{
   // Add all the animals to the list
   ArrayList pets = new ArrayList();
   pets.add(new Cat());
   pets.add(new Dog());
   pets.add(new Fish());

   // If the ability exists, then make a sound
   for(Object pet: pets)
   {
      if (pet instanceof CanSpeak)
      {
         CanSpeak loudmouth = (CanSpeak) pet;
         loudmouth.speak();
      }
   }
}

మీ ప్రోగ్రామ్‌లలో తరగతుల సంఖ్య వేలకు చేరుకున్నప్పుడు, మీరు ఇంటర్‌ఫేస్‌లు లేకుండా జీవించలేరు. వేలాది తరగతుల పరస్పర చర్యను వివరించడానికి బదులుగా, కొన్ని డజన్ల ఇంటర్‌ఫేస్‌ల పరస్పర చర్యను వివరించడానికి సరిపోతుంది - ఇది జీవితాన్ని చాలా సులభతరం చేస్తుంది.

మరియు పాలిమార్ఫిజంతో కలిపినప్పుడు, ఈ విధానం సాధారణంగా అద్భుతమైన విజయం.

3. defaultఇంటర్ఫేస్ పద్ధతుల అమలు

వియుక్త తరగతులు వేరియబుల్స్ మరియు పద్ధతుల అమలును కలిగి ఉంటాయి, కానీ అవి బహుళ వారసత్వాన్ని కలిగి ఉండవు. ఇంటర్‌ఫేస్‌లు వేరియబుల్స్ లేదా పద్ధతుల అమలును కలిగి ఉండకూడదు, కానీ అది బహుళ వారసత్వాన్ని కలిగి ఉంటుంది.

పరిస్థితి క్రింది పట్టికలో వ్యక్తీకరించబడింది:

కాబట్టి, కొంతమంది ప్రోగ్రామర్లు నిజంగా ఇంటర్‌ఫేస్‌లు పద్ధతి అమలులను కలిగి ఉండే సామర్థ్యాన్ని కలిగి ఉండాలని కోరుకున్నారు. కానీ ఒక పద్ధతి అమలును జోడించగల సామర్థ్యాన్ని కలిగి ఉండటం వలన ఒకటి ఎల్లప్పుడూ జోడించబడుతుందని కాదు. మీకు కావాలంటే జోడించండి. లేదా మీరు చేయకపోతే, చేయవద్దు.

అదనంగా, బహుళ వారసత్వంతో సమస్యలు ప్రధానంగా వేరియబుల్స్ కారణంగా ఉంటాయి. ఏదైనా సందర్భంలో, వారు నిర్ణయించుకున్నారు మరియు చేసారు. JDK 8తో ప్రారంభించి, ఇంటర్‌ఫేస్‌లకు మెథడ్ ఇంప్లిమెంటేషన్‌లను జోడించే సామర్థ్యాన్ని జావా పరిచయం చేసింది.

నవీకరించబడిన పట్టిక ఇక్కడ ఉంది (JDK 8 మరియు అంతకంటే ఎక్కువ కోసం):

ఇప్పుడు వియుక్త తరగతులు అలాగే ఇంటర్‌ఫేస్‌ల కోసం, మీరు అమలుతో లేదా లేకుండా పద్ధతులను ప్రకటించవచ్చు. మరియు ఇది అద్భుతమైన వార్త!

నైరూప్య తరగతులలో, అమలు లేకుండా పద్ధతులు తప్పనిసరిగా abstractకీవర్డ్‌తో ఉండాలి. మీరు అమలు చేసే పద్ధతులకు ముందు ఏదైనా జోడించాల్సిన అవసరం లేదు. ఇంటర్‌ఫేస్‌లలో, వ్యతిరేకం నిజం. ఒక పద్ధతి అమలు చేయకపోతే, ఏదీ జోడించాల్సిన అవసరం లేదు. కానీ అమలు ఉంటే, అప్పుడు defaultకీవర్డ్ జోడించబడాలి.

సరళత కోసం, మేము ఈ సమాచారాన్ని క్రింది చిన్న పట్టికలో అందిస్తున్నాము:

సమస్య

పద్ధతులను కలిగి ఉన్న ఇంటర్‌ఫేస్‌లను ఉపయోగించడం వలన పెద్ద తరగతి శ్రేణిని చాలా సులభతరం చేయవచ్చు. ఉదాహరణకు, వియుక్త InputStreamమరియు OutputStreamతరగతులను ఇంటర్‌ఫేస్‌లుగా ప్రకటించవచ్చు! ఇది వాటిని చాలా తరచుగా మరియు మరింత సౌకర్యవంతంగా ఉపయోగించడానికి అనుమతిస్తుంది.

కానీ ప్రపంచంలో ఇప్పటికే పది మిలియన్ల (బిలియన్ల?) జావా తరగతులు ఉన్నాయి. మరియు మీరు ప్రామాణిక లైబ్రరీలను మార్చడం ప్రారంభిస్తే, మీరు ఏదైనా విచ్ఛిన్నం చేయవచ్చు. ప్రతిదీ ఇష్టం! 😛

ఇప్పటికే ఉన్న ప్రోగ్రామ్‌లు మరియు లైబ్రరీలను అనుకోకుండా విచ్ఛిన్నం చేయకుండా ఉండటానికి, ఇంటర్‌ఫేస్‌లలో పద్ధతి అమలులు అతి తక్కువ వారసత్వ ప్రాధాన్యతను కలిగి ఉండాలని నిర్ణయించారు .

ఉదాహరణకు, ఒక ఇంటర్‌ఫేస్ ఒక పద్ధతిని కలిగి ఉన్న మరొక ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందినట్లయితే, మరియు మొదటి ఇంటర్‌ఫేస్ అదే పద్ధతిని ప్రకటించినప్పటికీ అమలు లేకుండా ఉంటే, అప్పుడు వారసత్వంగా పొందిన ఇంటర్‌ఫేస్ నుండి పద్ధతి అమలు ఇన్‌హెరిటింగ్ ఇంటర్‌ఫేస్‌కు చేరదు. ఉదాహరణ:

interface Pet
{
   default void meow()
   {
      System.out.println("Meow");
   }
}

interface Cat extends Pet
{
   void meow(); // Here we override the default implementation by omitting an implementation
}

class Tom implements Cat
{
}

Tomతరగతి పద్ధతిని అమలు చేయనందున కోడ్ కంపైల్ చేయబడదు meow().