CodeGym /జావా కోర్సు /మాడ్యూల్ 2: జావా కోర్ /ఇంటర్‌ఫేస్ ఇంటర్‌ఫేస్ కంటే ఎక్కువ. ఇది ఒక ప్రవర్తన.

ఇంటర్‌ఫేస్ ఇంటర్‌ఫేస్ కంటే ఎక్కువ. ఇది ఒక ప్రవర్తన.

మాడ్యూల్ 2: జావా కోర్
స్థాయి , పాఠం
అందుబాటులో ఉంది

"హలో, అమిగో! ఇది నేనే-మళ్లీ. నేను మీకు ఇంటర్‌ఫేస్‌లపై మరొక దృక్కోణాన్ని అందించాలనుకుంటున్నాను. మీరు చూడండి, చాలా సమయం తరగతి అనేది ఒక నిర్దిష్ట వస్తువు యొక్క నమూనా. దీనికి విరుద్ధంగా, ఇంటర్‌ఫేస్‌లు ఒక వస్తువు యొక్క సామర్థ్యాలు లేదా వస్తువు కాకుండా పాత్రలు."

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

జావా కోడ్ వివరణ
interface Moveable
{
void move(String newAddress);
}
కదిలే సామర్థ్యానికి అనుగుణంగా ఉంటుంది.
interface Driveable
{
void drive(Driver driver);
}
కదిలే సామర్థ్యానికి అనుగుణంగా ఉంటుంది.
interface Transport
{
void addStuff(Object stuff);
Object removeStuff();
}
సరుకు రవాణా చేసే సామర్థ్యానికి అనుగుణంగా ఉంటుంది.
class Wheel implements Moveable
{
...
}
ఒక "చక్రం" తరగతి. కదిలే సామర్థ్యం ఉంది.
class Car implements Moveable, Drivable, Transport
{
...
}
ఒక "కారు" తరగతి. ఒక వ్యక్తి ద్వారా నడపబడే, మరియు సరుకును మోసుకెళ్లే సామర్థ్యాన్ని కలిగి ఉంటుంది.
class Skateboard implements Moveable, Driveable
{
...
}
"స్కేట్‌బోర్డ్" తరగతి. ఒక వ్యక్తి ద్వారా కదలగల మరియు నియంత్రించగల సామర్థ్యాన్ని కలిగి ఉంటుంది.

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

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

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

కోడ్‌లో ఇది ఎలా ఉంటుందో ఇక్కడ ఉంది:

జావా కోడ్ వివరణ
static interface WallBuilder
{
void buildWall();
}
"గోడను నిర్మించే" సామర్థ్యం. «ఒక గోడను నిర్మించు» (తగిన పద్ధతిని కలిగి ఉంది) ఆదేశాన్ని అర్థం చేసుకుంటుంది.
static class WorkerRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class GuardRobot implements WallBuilder
{
void buildWall()
 {
…
 }
}
static class WateringCan
{
…
}
ఈ సామర్థ్యం/నైపుణ్యం ఉన్న రోబోలు.

నీరు త్రాగుట గోడను నిర్మించదు (ఇది WallBuilder ఇంటర్‌ఫేస్‌ను అమలు చేయదు).

public static void main(String[] args)
{
 //add all robots to a list
 ArrayList robots = new ArrayList();
 robots.add(new WorkerRobot());
 robots.add(new GuardRobot());
 robots.add(new WateringCan());

 //build a wall if you can
 for (Object robot: robots)
 {
  if (robot instanceof WallBuilder)
  {
   WallBuilder builder = (WallBuilder) robot;
   builder.buildWall();
   }
  }
 }
}
గోడ కట్టమని ఆదేశం ఎలా ఇవ్వాలి?

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

"ఆపై కొన్ని! బహురూపతతో కలిపి, ఇది పూర్తిగా మనస్సును కదిలించేది."

వ్యాఖ్యలు
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION