హాయ్! ఈ రోజు మనం జావాలో ఒక ముఖ్యమైన కాన్సెప్ట్ గురించి మాట్లాడబోతున్నాం: ఇంటర్‌ఫేస్‌లు. ఈ పదం బహుశా మీకు సుపరిచితమే. ఉదాహరణకు, చాలా కంప్యూటర్ ప్రోగ్రామ్‌లు మరియు గేమ్‌లు ఇంటర్‌ఫేస్‌లను కలిగి ఉంటాయి. విస్తృత కోణంలో, ఇంటర్ఫేస్ అనేది రెండు పరస్పర చర్య చేసే పార్టీలను కలిపే ఒక రకమైన 'రిమోట్ కంట్రోల్'. రోజువారీ జీవితంలో ఇంటర్‌ఫేస్‌కి ఒక సాధారణ ఉదాహరణ టీవీ రిమోట్ కంట్రోల్. ఇది ఒక వ్యక్తి మరియు టీవీ అనే రెండు వస్తువులను కలుపుతుంది మరియు విభిన్నమైన పనులను చేస్తుంది: వాల్యూమ్‌ను పెంచండి లేదా తగ్గించండి, ఛానెల్‌లను మార్చండి మరియు టీవీని ఆన్ లేదా ఆఫ్ చేయండి. ఒక పక్షం (వ్యక్తి) ఇంటర్‌ఫేస్‌ను యాక్సెస్ చేయాలి (రిమోట్ కంట్రోల్‌లో బటన్‌ను నొక్కండి) రెండవ పక్షం చర్యను అమలు చేయడానికి కారణం అవుతుంది. ఉదాహరణకు, టీవీని తదుపరి ఛానెల్‌కి మార్చడానికి. ఇంకేముంది, వినియోగదారు చేయరు' టీవీ ఎలా నిర్వహించబడుతుందో లేదా ఛానెల్ మార్చే ప్రక్రియ అంతర్గతంగా ఎలా అమలు చేయబడుతుందో తెలుసుకోవాలి. వినియోగదారుకు ప్రాప్యత ఉన్న ఏకైక విషయం ఇంటర్ఫేస్. ఆశించిన ఫలితాన్ని పొందడం ప్రధాన లక్ష్యం. ప్రోగ్రామింగ్ మరియు జావాతో దీనికి సంబంధం ఏమిటి? అంతా :) ఇంటర్‌ఫేస్‌ని సృష్టించడం అనేది సాధారణ తరగతిని సృష్టించడం వలె ఉంటుంది, కానీ బదులుగా పదాన్ని ఉపయోగించడంతరగతి , మేము ఇంటర్ఫేస్ అనే పదాన్ని సూచిస్తాము . సరళమైన జావా ఇంటర్‌ఫేస్‌ను చూద్దాం, ఇది ఎలా పని చేస్తుందో మరియు మనకు ఇది ఎందుకు అవసరమో చూద్దాం:
public interface CanSwim {
public void swim();
}
మేము CanSwim ఇంటర్‌ఫేస్‌ని సృష్టించాము . ఇది మన రిమోట్ కంట్రోల్ లాంటిది, కానీ ఒక 'బటన్'తో: ఈత() పద్ధతి. అయితే ఈ రిమోట్ కంట్రోలర్‌ని ఎలా ఉపయోగించాలి? దీన్ని చేయడానికి, మేము ఒక పద్ధతిని అమలు చేయాలి, అనగా మా రిమోట్ కంట్రోల్ బటన్. ఇంటర్‌ఫేస్‌ని ఉపయోగించడానికి, మా ప్రోగ్రామ్‌లోని కొన్ని తరగతులు తప్పనిసరిగా దాని పద్ధతులను అమలు చేయాలి. వస్తువులు 'ఈత కొట్టగల' తరగతిని ఆవిష్కరిద్దాం. ఉదాహరణకు, డక్ క్లాస్ సరిపోతుంది:
public class Duck implements CanSwim {
public void swim() {
System.out.println("Duck, swim!");
}
public static void main(String[] args) {
Duck duck = new Duck();
duck.swim();
}
}
"మనం ఇక్కడ ఏమి చూస్తాము? డక్ క్లాస్ అనేది ఇంప్లిమెంట్స్ కీవర్డ్ ద్వారా CanSwim ఇంటర్ఫేస్తో 'అనుబంధించబడింది' . వారసత్వం ద్వారా రెండు తరగతులను అనుబంధించడానికి మేము ఇదే విధమైన మెకానిజమ్‌ని ఉపయోగించినట్లు మీకు గుర్తు ఉండవచ్చు, కానీ ఆ సందర్భంలో మేము పొడిగింపు అనే పదాన్ని ఉపయోగించాము. పూర్తి స్పష్టత, మేము ' పబ్లిక్ క్లాస్ డక్ ఇంప్లిమెంట్స్ CanSwim 'ని అక్షరాలా ఇలా అనువదించవచ్చు : 'పబ్లిక్ డక్ క్లాస్ CanSwim ఇంటర్‌ఫేస్‌ను అమలు చేస్తుంది '. దీని అర్థం ఇంటర్ఫేస్తో అనుబంధించబడిన తరగతి దాని అన్ని పద్ధతులను అమలు చేయాలి. గమనిక: మా తరగతి, అలాగే ఇంటర్ఫేస్ , ఒక పద్ధతిని కలిగి ఉంది మరియు అది కొంత తర్కాన్ని కలిగి ఉంటుంది. ఇది తప్పనిసరి అవసరం. మనం వ్రాస్తేDuckCanSwimswim()public class Duck implements CanSwimswim()క్లాస్‌లో పద్ధతిని సృష్టించకుండా Duck, కంపైలర్ మనకు ఎర్రర్‌ను ఇస్తుంది: డక్ అబ్‌స్ట్రాక్ట్ కాదు మరియు క్యాన్‌స్విమ్‌లో వియుక్త పద్ధతి స్విమ్()ని ఓవర్‌రైడ్ చేయదు ఎందుకు? ఇది ఎందుకు జరుగుతుంది? మేము టీవీ ఉదాహరణను ఉపయోగించి లోపాన్ని వివరిస్తే, ఛానెల్‌లను మార్చలేని 'ఛానెల్ మార్చు' బటన్‌తో టీవీ రిమోట్ కంట్రోల్‌ను ఎవరికైనా అందజేసినట్లు అవుతుంది. మీరు బటన్‌ను మీకు నచ్చినంత ఎక్కువగా నొక్కవచ్చు, కానీ అది పని చేయదు. రిమోట్ కంట్రోల్ స్వయంగా ఛానెల్‌లను మార్చదు: ఇది టీవీకి సిగ్నల్‌ను మాత్రమే పంపుతుంది, ఇది ఛానెల్ మార్చే సంక్లిష్ట ప్రక్రియను అమలు చేస్తుంది. మరియు అది మా బాతుతో ఉంటుంది: ఇది ఈత ఎలా చేయాలో తెలుసుకోవాలి కాబట్టి దీనిని ఇంటర్ఫేస్ ఉపయోగించి పిలుస్తారు CanSwim. అది ఎలాగో తెలియకపోతే, దిCanSwimవ్యక్తి మరియు ప్రోగ్రామ్ అనే రెండు పార్టీలను ఇంటర్ఫేస్ కనెక్ట్ చేయదు. ప్రోగ్రామ్ లోపల ఈత swim()కొట్టడానికి వ్యక్తి ఈ పద్ధతిని ఉపయోగించలేరు . Duckఇంటర్‌ఫేస్‌లు ఏమిటో ఇప్పుడు మీరు మరింత స్పష్టంగా అర్థం చేసుకున్నారు. ఇంటర్‌ఫేస్‌ని అమలు చేసే తరగతులు తప్పనిసరిగా కలిగి ఉండే ప్రవర్తనను ఇంటర్ఫేస్ వివరిస్తుంది. 'బిహేవియర్' అనేది పద్ధతుల సమాహారం. మేము అనేక మెసెంజర్‌లను సృష్టించాలనుకుంటే, Messengerఇంటర్‌ఫేస్‌ను సృష్టించడం చాలా సులభమైన పని. ప్రతి దూతకి ఏమి కావాలి? ప్రాథమిక స్థాయిలో, వారు తప్పనిసరిగా సందేశాలను స్వీకరించగలరు మరియు పంపగలరు.
public interface Messenger{
public void sendMessage();
public void getMessage();
}
ఇప్పుడు మనం సంబంధిత ఇంటర్‌ఫేస్‌ను అమలు చేసే మా మెసెంజర్ తరగతులను సృష్టించవచ్చు. కంపైలర్ స్వయంగా మన తరగతులలో వాటిని అమలు చేయమని 'బలవంతం' చేస్తుంది. టెలిగ్రామ్:
public class Telegram implements Messenger {
public void sendMessage() {
System.out.println("Sending a Telegram message!");
}
public void getMessage() {
System.out.println("Receiving a Telegram message!");
}
}
WhatsApp:
public class WhatsApp implements Messenger {
public void sendMessage() {
System.out.println("Sending a WhatsApp message!");
}
public void getMessage() {
System.out.println("Reading a WhatsApp message!");
}
}
Viber:
public class Viber implements Messenger {
public void sendMessage() {
System.out.println("Sending a Viber message!");
}
public void getMessage() {
System.out.println("Receiving a Viber message!");
}
}
ఇది ఏ ప్రయోజనాలను అందిస్తుంది? వాటిలో ముఖ్యమైనది వదులుగా కలపడం. మేము క్లయింట్ డేటాను సేకరించే ప్రోగ్రామ్‌ను రూపొందిస్తున్నామని ఊహించుకోండి. Clientక్లయింట్ ఏ నిర్దిష్ట మెసెంజర్‌ని ఉపయోగిస్తున్నారో సూచించడానికి తరగతికి ఖచ్చితంగా ఫీల్డ్ అవసరం . ఇంటర్‌ఫేస్‌లు లేకుండా, ఇది విచిత్రంగా కనిపిస్తుంది:
public class Client {
private WhatsApp whatsApp;
private Telegram telegram;
private Viber viber;
}
మేము మూడు ఫీల్డ్‌లను సృష్టించాము, కానీ క్లయింట్‌కి ఒక మెసెంజర్ మాత్రమే ఉంటుంది. మనకు ఏది తెలియదు. కాబట్టి క్లయింట్‌తో కమ్యూనికేట్ చేయడానికి మేము ప్రతి అవకాశాన్ని తరగతికి జోడించాలి. nullవాటిలో ఒకటి లేదా రెండు ఎల్లప్పుడూ ప్రోగ్రామ్‌కు పూర్తిగా అవసరం లేదని తేలింది . బదులుగా మా ఇంటర్‌ఫేస్‌ని ఉపయోగించడం ఉత్తమం:
public class Client {
private Messenger messenger;
}
వదులుగా కలపడానికి ఇది ఒక ఉదాహరణ! తరగతిలో నిర్దిష్ట మెసెంజర్ తరగతిని పేర్కొనడానికి బదులుగా Client, క్లయింట్‌కు మెసెంజర్ ఉందని మేము సూచిస్తాము. ప్రోగ్రామ్ నడుస్తున్నప్పుడు ఏది ఖచ్చితంగా నిర్ణయించబడుతుంది. అయితే దీని కోసం మనకు ఇంటర్‌ఫేస్‌లు ఎందుకు అవసరం? అవి కూడా భాషలో ఎందుకు చేర్చబడ్డాయి? ఇది మంచి ప్రశ్న - మరియు సరైన ప్రశ్న! సాధారణ వారసత్వాన్ని ఉపయోగించి మనం అదే ఫలితాన్ని సాధించలేమా? తరగతి Messengerతల్లిదండ్రులుగా, మరియు Viber, Telegram, మరియు WhatsAppపిల్లలుగా. నిజానికి, అది సాధ్యమే. కానీ ఒక చిక్కు ఉంది. మీకు ఇప్పటికే తెలిసినట్లుగా, జావాకు బహుళ వారసత్వం లేదు. కానీ బహుళ ఇంటర్‌ఫేస్‌లకు మద్దతు ఉంది. ఒక తరగతి మీకు కావలసినన్ని ఇంటర్‌ఫేస్‌లను అమలు చేయగలదు. Smartphoneమనకు ఒక తరగతి ఉందని ఊహించుకోండిAppఫీల్డ్, ఇది స్మార్ట్‌ఫోన్‌లో ఇన్‌స్టాల్ చేయబడిన యాప్‌ను సూచిస్తుంది.
public class Smartphone {
private App app;
}
వాస్తవానికి, యాప్ మరియు మెసెంజర్ ఒకేలా ఉంటాయి, కానీ అవి ఇప్పటికీ భిన్నమైనవి. మెసెంజర్ యొక్క మొబైల్ మరియు డెస్క్‌టాప్ వెర్షన్‌లు ఉండవచ్చు, కానీ యాప్ ప్రత్యేకంగా మొబైల్ యాప్‌ను సూచిస్తుంది. Telegramఇక్కడ ఒప్పందం ఉంది — మేము వారసత్వాన్ని ఉపయోగించినట్లయితే, మేము తరగతికి ఒక వస్తువును జోడించలేము Smartphone. అన్నింటికంటే, Telegramతరగతి ఏకకాలంలో వారసత్వంగా పొందదు Appమరియు Messenger! మరియు మేము దీన్ని ఇప్పటికే వారసత్వంగా పొందాము Messengerమరియు దానిని తరగతికి జోడించాము Client. కానీ Telegramతరగతి రెండు ఇంటర్‌ఫేస్‌లను సులభంగా అమలు చేయగలదు! Clientదీని ప్రకారం, మేము తరగతికి ఒక Telegramవస్తువును ఇవ్వవచ్చు మరియు మేము దానిని తరగతికి ఒక వలె Messengerఇవ్వవచ్చు . మీరు దీన్ని ఎలా చేస్తారో ఇక్కడ ఉంది: SmartphoneApp
public class Telegram implements Application, Messenger {
// ...methods
}
public class Client {
private Messenger messenger;
public Client() {
this.messenger = new Telegram();
}
}
public class Smartphone {
private Application application;
public Smartphone() {
this.application = new Telegram();
}
}
ఇప్పుడు మేము Telegramతరగతిని ఎలా ఉపయోగించాలనుకుంటున్నామో అలా ఉపయోగిస్తున్నాము. కొన్ని ప్రదేశాలలో, ఇది ఒక App. ఇతర ప్రదేశాలలో, ఇది ఒక Messenger. ఇంటర్ఫేస్ పద్ధతులు ఎల్లప్పుడూ 'ఖాళీ'గా ఉన్నాయని మీరు ఖచ్చితంగా ఇప్పటికే గమనించారు, అంటే వాటికి ఎటువంటి అమలు ఉండదు. దీనికి కారణం చాలా సులభం: ఇంటర్ఫేస్ ప్రవర్తనను వివరిస్తుంది, కానీ అది అమలు చేయదు. 'ఇంటర్‌ఫేస్‌ను అమలు చేసే అన్ని వస్తువులు CanSwimఈత కొట్టగలగాలి': ఇంటర్ఫేస్ మనకు చెప్పేది అంతే. చేపలు, బాతులు మరియు గుర్రాలు ఈత కొట్టే నిర్దిష్ట మార్గం Fish, Duck, మరియుHorseతరగతులు, ఇంటర్ఫేస్ కాదు. టీవీకి ఛానల్ మార్చడం లాంటిది. రిమోట్ మీకు దీని కోసం ఒక బటన్‌ను ఇస్తుంది. అయినప్పటికీ, జావా 8 - డిఫాల్ట్ పద్ధతులలో ఆసక్తికరమైన జోడింపు కనిపించింది. ఉదాహరణకు, మీ ఇంటర్‌ఫేస్‌లో 10 పద్ధతులు ఉన్నాయి. వాటిలో 9 వేర్వేరు తరగతులలో వేర్వేరు అమలులను కలిగి ఉన్నాయి, అయితే ఒకటి అందరికీ ఒకే విధంగా అమలు చేయబడుతుంది. మునుపు, జావా 8కి ముందు, ఇంటర్ఫేస్ పద్ధతులకు ఏ విధమైన అమలు లేదు: కంపైలర్ వెంటనే లోపాన్ని అందించింది. ఇప్పుడు మీరు ఇలా చేయవచ్చు:
public interface CanSwim {
public default void swim() {
System.out.println("Swim!");
}
public void eat();
public void run();
}
కీవర్డ్‌ని ఉపయోగించి default, మేము డిఫాల్ట్ అమలుతో ఇంటర్ఫేస్ పద్ధతిని సృష్టించాము. అమలు చేసే అన్ని తరగతులలో - eat()మరియు - రెండు ఇతర పద్ధతుల కోసం మేము మా స్వంత అమలును అందించాలి . మేము దీన్ని పద్ధతితో చేయవలసిన అవసరం లేదు : ప్రతి తరగతిలో అమలు ఒకే విధంగా ఉంటుంది. మార్గం ద్వారా, మీరు ఇప్పటికే గత టాస్క్‌లలో ఇంటర్‌ఫేస్‌లను చూశారు, మీరు గమనించకపోయినా :) ఇక్కడ ఒక స్పష్టమైన ఉదాహరణ: మీరు మరియు ఇంటర్‌ఫేస్‌లతో పని చేసారు! మరింత ఖచ్చితంగా, మీరు వాటి అమలులతో పని చేసారు — , , , మొదలైనవి. ఒకే సమయంలో ఒక తరగతి బహుళ ఇంటర్‌ఫేస్‌లను అమలు చేసే ఉదాహరణను అదే రేఖాచిత్రం స్పష్టంగా ఇస్తుంది. ఉదాహరణకు, అమలు చేస్తుంది మరియుrun()CanSwimswim()ListSetArrayListLinkedListHashSetLinkedListListDeque(డబుల్-ఎండ్ క్యూ) ఇంటర్‌ఫేస్‌లు. మీకు Mapఇంటర్ఫేస్ లేదా దాని HashMapఅమలు గురించి బాగా తెలుసు. మార్గం ద్వారా, ఈ రేఖాచిత్రం ఒక లక్షణాన్ని వివరిస్తుంది: ఇంటర్‌ఫేస్‌లు ఇతర ఇంటర్‌ఫేస్‌లను వారసత్వంగా పొందవచ్చు. ఇంటర్ఫేస్ SortedMapవారసత్వంగా పొందుతుంది Map, అయితే Dequeవారసత్వంగా ఉంటుంది Queue. మీరు ఇంటర్‌ఫేస్‌ల మధ్య సంబంధాన్ని చూపించాలనుకుంటే ఇది అవసరం, ఇక్కడ ఒక ఇంటర్ఫేస్ మరొకదాని యొక్క పొడిగించిన సంస్కరణ. ఇంటర్ఫేస్తో ఒక ఉదాహరణను పరిశీలిద్దాం Queue. మేము ఇంకా సమీక్షించలేదుQueues, కానీ ఇది చాలా సులభం మరియు స్టోర్ వద్ద సాధారణ క్యూ లేదా లైన్ లాగా పనిచేస్తుంది. మీరు క్యూ చివరిలో మాత్రమే అంశాలను జోడించగలరు మరియు వాటిని మొదటి నుండి మాత్రమే తీసుకోగలరు. ఏదో ఒక సమయంలో, డెవలపర్‌లకు రెండు చివర్లలో ఐటెమ్‌లను జోడించడానికి మరియు తీసుకోవడానికి క్యూ యొక్క మెరుగైన వెర్షన్ అవసరం. కాబట్టి వారు ఇంటర్‌ఫేస్‌ను సృష్టించారు Deque, ఇది డబుల్-ఎండ్ క్యూ. ఇది సాధారణ క్యూలో ఉన్న అన్ని పద్ధతులను కలిగి ఉంది. అన్నింటికంటే, ఇది డబుల్-ఎండ్ క్యూ యొక్క పేరెంట్, కానీ ఇది కొత్త పద్ధతులను కూడా జోడిస్తుంది.
GO TO FULL VERSION