ఇంటర్‌ఫేస్‌లు

"హలో, అమిగో! ఈరోజు మీరు కొన్ని ఆవిష్కరణలు చేయబోతున్నారు. ఈరోజు టాపిక్-డ్రమ్ రోల్, దయచేసి-ఇంటర్‌ఫేస్‌లు. "

"అవును. ఒక రోజు చాలా అద్భుతంగా ఉంది, నేను స్నానం చేయడానికి ఇంటికి వెళ్తున్నాను."

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

interface Drawable
{
void draw();
}
interface HasValue
{
int getValue();
}

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

class abstract ChessItem implements Drawable, HasValue
{
private int x, y, value;

public int getValue()
{
return value;
}

public int getX()
{
return x;
}

public int getY()
{
return y;
}

}

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

"తరగతుల కంటే ఇంటర్‌ఫేస్‌లు రెండు బలమైన ప్రయోజనాలను కలిగి ఉన్నాయి:"

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

మీరు మీ తరగతికి సంబంధించిన పద్ధతులను కాల్ చేయడానికి ఇతర తరగతులను అనుమతించాలనుకుంటే, మీరు వాటిని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());
}

మేము మా తరగతిని రెండు ముక్కలుగా విభజించాము: ఇంటర్‌ఫేస్ మరియు ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతి.

"కాబట్టి ప్రయోజనం ఏమిటి?"

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

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

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

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

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

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