జావాలో అమలవుతుంది

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

ఇంటర్ఫేస్ మరియు అమలు అంటే ఏమిటి

మీరు బహుశా "ఇంటర్ఫేస్" అనే పదాన్ని చాలాసార్లు విన్నారు. ఉదాహరణకు, కంప్యూటర్‌కు ఇన్‌పుట్ ఇంటర్‌ఫేస్ (మౌస్ మరియు కీబోర్డ్) ఉంటుంది, అనేక ప్రోగ్రామ్‌లు యూజర్ ఇంటర్‌ఫేస్‌లను కలిగి ఉంటాయి. విస్తృత కోణంలో, ఇంటర్‌ఫేస్ అనేది రెండు పరస్పర చర్య చేసే పార్టీల మధ్య లింక్. ఉదాహరణకు, అదే కీబోర్డ్ లేదా టీవీ రిమోట్ కంట్రోల్. ప్రోగ్రామింగ్‌లో మరియు ముఖ్యంగా జావాలో, ఇంటర్‌ఫేస్ అనేది ఒక నిర్దిష్ట ఒప్పందం, అది అమలు చేసే తరగతి ఏమి చేస్తుందో తెలియజేస్తుంది. ఇంటర్‌ఫేస్ ప్రవర్తనను మాత్రమే నిర్వచిస్తుంది. దాన్ని అమలు చేసే వస్తువు గురించి ఏమీ చెప్పలేదు. మీరు జావాలో ఇంటర్‌ఫేస్‌ను ఇలా ప్రకటించవచ్చు:

public interface MyInterface  {

     // constants declaration 
     // methods without implementation
     // static methods
     // default methods (default)
     // private methods
}

జావాలో ఇంప్లిమెంట్స్ యొక్క సింటాక్స్ ఇక్కడ ఉంది :

public class MyClass implements MyInterface{
//implementing the methods of MyInterface 
//Other code
} 

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

కీవర్డ్ ఉదాహరణను అమలు చేయండి

public interface Swimmable {
  
   void moveForward();
   void TurnRight();
   void TurnLeft();
  
}

మీరు గమనిస్తే, పద్ధతులు తాము అమలు చేయబడవు. కానీ ఈ ఇంటర్‌ఫేస్‌ను అమలు చేసే తరగతులు తప్పనిసరిగా సరళ రేఖలో ఈత కొట్టగలగాలి, అలాగే కుడి మరియు ఎడమవైపు తిరగగలవని మేము ప్రకటించాము. ఈ ఇంటర్‌ఫేస్‌ని అమలు చేసే తరగతులను సృష్టిద్దాం.

public class Duck implements Swimmable {
//implementing the methods
   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

}

public class Fish implements Swimmable {

   public void moveForward() {
       System.out.println("I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft() {
       System.out.println("I am turning left...");
   }

   public void turnUp(){
       System.out.println("I am turning up...");
   }

   public void turnDown(){
       System.out.println("I am turning down...");
   }

   public void Stop() {
       System.out.println("I am relaxing somewhere under the water surface...");
   }
}

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

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

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

To implement multiple interfaces, use the next syntax: 
interface MyFirstInterface {
   public void myMethod();
}
interface MySecondInterface {
   public void myOtherMethod();
}

// MyClass implements both MyFirstInterface and MySecondInterface
class MyClass implements MyFirstInterface, MySecondInterface {
   public void myMethod() {
      //method implementation
   }
   public void myOtherMethod() {
     //method implementation
   }
}

బహుళ ఇంటర్‌ఫేస్‌ల ఉదాహరణ

బాతు ఈత కొట్టడమే కాకుండా ఎగరగలదని గుర్తుంచుకోండి. ఫ్లైట్ ఇంటర్‌ఫేస్‌ని వ్రాసి మన బాతులో అమలు చేద్దాం.

public interface Flyable {
   double startAge = 0.1;
   void fly();
}

public class Duck implements Swimmable, Flyable {

   public void moveForward() {
       System.out.println(" Quack, I am moving forward...");
   }

   public void TurnRight(){
       System.out.println("I am turning right...");
   }
   public void TurnLeft(){
       System.out.println("I am turning left...");

   }

   public void Stop() {
       System.out.println("Quack. I am relaxing on the surface of the water...");
   }

   public void fly(){
       System.out.println("I am flying!!!");
   }

}

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