జావాలో ఇంటర్‌ఫేస్‌లు

1. ఇంటర్‌ఫేస్‌లను పరిచయం చేస్తోంది

ఈ రోజు మీ జ్ఞానం కోసం రోజు. మరొక కొత్త మరియు ఆసక్తికరమైన అంశం ఇంటర్‌ఫేస్‌లు.

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

interface Feline
{
   void purr();
   void meow();
   void growl();
}

ఇంటర్‌ఫేస్‌ల గురించి కొన్ని ఉపయోగకరమైన వాస్తవాలు ఇక్కడ ఉన్నాయి:

1. ఇంటర్‌ఫేస్‌ను ప్రకటించడం

interface Drawable
{
   void draw();
}

interface HasValue
{
   int getValue();
}

1. కీవర్డ్‌కు బదులుగా class, మేము వ్రాస్తాము interface.
2. ఇది నైరూప్య పద్ధతులను మాత్రమే కలిగి ఉంది (కీవర్డ్‌ని వ్రాయవద్దు abstract)
3. నిజానికి, ఇంటర్‌ఫేస్‌లు అన్నిpublic పద్ధతులను కలిగి ఉంటాయి

ఇంటర్‌ఫేస్ ఇంటర్‌ఫేస్‌లను మాత్రమే వారసత్వంగా పొందగలదు. కానీ ఇంటర్‌ఫేస్‌లో చాలా మంది తల్లిదండ్రులు ఉండవచ్చు. దీన్ని చెప్పడానికి మరొక మార్గం ఏమిటంటే, జావాకు ఇంటర్‌ఫేస్‌ల బహుళ వారసత్వం ఉందని చెప్పడం. ఉదాహరణలు:

interface Piece extends Drawable, HasValue
{
   int getX();
   int getY();
}

3. ఇంటర్‌ఫేస్‌ల నుండి తరగతులను వారసత్వంగా పొందడం

ఒక తరగతి బహుళ ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందవచ్చు (ఒక తరగతి నుండి మాత్రమే). ఇది కీవర్డ్ ఉపయోగించి చేయబడుతుంది implements. ఉదాహరణ:

abstract class ChessItem implements Drawable, HasValue
{
   private int x, y, value;
   public int getValue()
   {
      return value;
   }

   public int getX()
   {
      return x;
   }

   public  int getY()
   {
      return y;
   }
}

ChessItem తరగతి వియుక్తంగా ప్రకటించబడింది: ఇది మినహా అన్ని వారసత్వ పద్ధతులను అమలు చేస్తుంది draw. మరో మాటలో చెప్పాలంటే, ChessItemతరగతి ఒక వియుక్త పద్ధతిని కలిగి ఉంది — draw().

extendsమరియు కీలక పదాల యొక్క సాంకేతిక అర్ధం implementsఒకటే: రెండూ వారసత్వం. కోడ్ యొక్క రీడబిలిటీని మెరుగుపరచడానికి ఈ వ్యత్యాసం చేయబడింది. తరగతులు వారసత్వంగా (ద్వారా ) మరియు ఇంటర్‌ఫేస్‌లు (ద్వారా ) extendsఅమలు చేయబడతాయని కూడా మేము చెబుతున్నాము.implements

4. వేరియబుల్స్

ఇక్కడ చాలా ముఖ్యమైన విషయం ఏమిటంటే: సాధారణ వేరియబుల్స్ ఇంటర్‌ఫేస్‌లలో ప్రకటించబడవు (అయితే స్టాటిక్ వాటిని చేయవచ్చు).

కానీ మనకు ఇంటర్‌ఫేస్‌లు ఎందుకు అవసరం? అవి ఎప్పుడు ఉపయోగించబడతాయి? తరగతుల కంటే ఇంటర్‌ఫేస్‌లు రెండు బలమైన ప్రయోజనాలను కలిగి ఉన్నాయి:

2. వారి అమలు నుండి "పద్ధతుల వివరణ" వేరు చేయడం.

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

ఇంటర్‌ఫేస్‌లు ఈ విభాగాన్ని మరింత బలోపేతం చేయడానికి సహాయపడతాయి. మేము ఒక ప్రత్యేక "అందరూ ఉపయోగించడానికి తరగతి" అలాగే రెండవ తరగతి "మా స్వంత ఉపయోగం కోసం మాత్రమే" చేస్తాము, ఇది మొదటి తరగతిని వారసత్వంగా పొందుతుంది. ఇది సుమారుగా ఎలా ఉంటుందో ఇక్కడ ఉంది:

class Student
{
   private String name;
   public Student(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return this.name;
   }

   private void setName(String name)
   {
      this.name = name;
   }

interface Student
{
   public String getName();
}

class StudentImpl implements Student
{
   private String name;
   public StudentImpl(String name)
   {
      this.name = name;
   }

   public String getName()
   {
      return this.name;
   }

   private void setName(String name)
   {
      this.name = name;
   }
}

public static void main(String[] args)
{
   Student student = new Student("Alibaba");
   System.out.println(student.getName());
}

public static void main(String[] args)
{
   Student student = new StudentImpl("Ali")
   System.out.println(student.getName());
}

మేము మా తరగతిని రెండుగా విభజించాము : ఇంటర్‌ఫేస్ మరియు ఇంటర్‌ఫేస్‌ను వారసత్వంగా పొందే తరగతి . మరియు ఇక్కడ ప్రయోజనం ఏమిటి?

అనేక విభిన్న తరగతులు ఒకే ఇంటర్‌ఫేస్‌ను అమలు చేయగలవు (వారసత్వం). మరియు ప్రతి ఒక్కరికి దాని స్వంత ప్రవర్తన ఉంటుంది. ఉదాహరణకు, ఇంటర్ఫేస్ ArrayList LinkedListయొక్క రెండు వేర్వేరు అమలులు List.

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

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

3. బహుళ వారసత్వం

జావాలో, అన్ని తరగతులకు ఒక పేరెంట్ క్లాస్ మాత్రమే ఉంటుంది. ఇతర ప్రోగ్రామింగ్ భాషలలో, తరగతులు తరచుగా బహుళ పేరెంట్ తరగతులను కలిగి ఉంటాయి. ఇది చాలా సౌకర్యవంతంగా ఉంటుంది, కానీ అనేక సమస్యలను కూడా తెస్తుంది.

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

వారు తరగతుల బహుళ వారసత్వాన్ని ఎందుకు నిషేధించారు, అయితే ఇంటర్‌ఫేస్‌ల బహుళ వారసత్వాన్ని ఎందుకు అనుమతించారు? డైమండ్ వారసత్వ సమస్య అని పిలవబడే కారణంగా :

B తరగతి A తరగతిని వారసత్వంగా పొందినప్పుడు, C మరియు D తరగతుల గురించి ఏమీ తెలియదు. కనుక ఇది సరిపోయేటట్లుగా A తరగతి యొక్క వేరియబుల్స్‌ను ఉపయోగిస్తుంది. C క్లాస్ అదే చేస్తుంది: ఇది A క్లాస్ యొక్క వేరియబుల్స్‌ని ఉపయోగిస్తుంది, కానీ వేరే విధంగా. మరియు ఇవన్నీ D తరగతిలో సంఘర్షణకు దారితీస్తాయి.

కింది సాధారణ ఉదాహరణను చూద్దాం. మనకు 3 తరగతులు ఉన్నాయని అనుకుందాం:

class Data
{
   protected int value;
}

class XCoordinate extends Data
{
   public void setX (int x) { value = x;}
   public int getX () { return value;}
}

class YCoordinate extends Data
{
   public void setY (int y) { value = y;}
   public int getY () { return value; }
}

డేటా క్లాస్ valueవేరియబుల్‌ను నిల్వ చేస్తుంది. దాని XCoordinate డిసెండెంట్ క్లాస్ విలువను నిల్వ చేయడానికి ఆ వేరియబుల్‌ని ఉపయోగిస్తుంది xమరియు YCoordinateడిసెండెంట్ క్లాస్ విలువను నిల్వ చేయడానికి దాన్ని ఉపయోగిస్తుంది y.

మరియు అది పనిచేస్తుంది. విడిగా. XCoordinateఅయితే XYCoordinates తరగతి మరియు తరగతులు రెండింటినీ వారసత్వంగా పొందాలని మనం కోరుకుంటే YCoordinate, అప్పుడు మనకు విరిగిన కోడ్ వస్తుంది. ఈ తరగతి దాని పూర్వీకుల తరగతుల పద్ధతులను కలిగి ఉంటుంది, కానీ అవి సరిగ్గా పని చేయవు, ఎందుకంటే అవి ఒకే విధంగా ఉంటాయి value variable.

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