Implementer i Java

När vissa talar om Java OOP-paradigmet för arv, menar de vanligtvis att utöka en förälderklass med en arvtagare, en barnklass. Men när du stöter på nyckelordet Java implements betyder det att vi flyttar till en annan abstraktionsnivå och börjar arbeta med gränssnitt i Java. Vi kommer att prata om vad gränssnitt är, vad de är till för, hur implementering sker.

Vad är gränssnitt och implementering

Du har säkert hört ordet "gränssnitt" många gånger. En dator har till exempel ett ingångsgränssnitt (mus och tangentbord), många program har användargränssnitt. I vid bemärkelse är ett gränssnitt en länk mellan två samverkande parter. Till exempel samma tangentbord eller TV-fjärrkontroll. Inom programmering, och i Java i synnerhet, är ett gränssnitt ett specifikt kontrakt som säger vad klassen som implementerar det kommer att göra. Ett gränssnitt definierar bara beteende. Det står inget om objektet som ska implementera det. Du kan deklarera ett gränssnitt i Java så här:

public interface MyInterface  {

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

Här är en syntax för Implements i Java:

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

Ett gränssnitt beskriver beteende utan att specificera det. Till exempel kan ett beteende som "rörelse" appliceras på olika typer av föremål: en cykel, en person, en bil, vatten i en flod och så vidare. Simbeteendet kan vara beteendet hos en anka, ett fartyg eller en fisk. Dessa föremål har inget gemensamt annat än att de kan röra sig eller simma. Ja, och själva rörelsen med simning de är väldigt olika. Men i Java kan du skapa klasser Anka , Båt , Fisk och låta dem implementera förmågan att simma. Det är här nyckelordet Java Implements används.

Implementera sökordsexempel

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

Som du kan se är själva metoderna inte implementerade. Men vi deklarerade att klasserna som implementerar detta gränssnitt måste kunna simma i en rak linje, samt svänga höger och vänster. Låt oss skapa klasser som kommer att implementera detta gränssnitt.

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...");
   }
}

Alla klasser som implementerar Swimmable- gränssnittet måste enligt kontraktet kunna simma framåt (implementera moveForward()- metoden), samt svänga höger och vänster. Implementering av dessa metoder krävs. En anka och en fisk simmar olika. Låt oss säga att en fisk har ytterligare två metoder som implementerar dess förmåga att simma upp och ner. Det simbara gränssnittet har inte detta. Men om vi skapar ett barn i fiskklassen, till exempel tonfisk eller lax, kommer de, precis som alla "fiskar", att kunna simma upp och ner.

Flera gränssnitt i Java

Som du säkert redan vet, stöder inte Java multipelt arv. Det betyder att en klass bara kan ärvas från en superklass. Men på ett sätt kan du fortfarande använda "multiple inheritance" i Java, eftersom en klass kan implementera flera gränssnitt.

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
   }
}

Exempel på flera gränssnitt

Kom ihåg att en anka inte bara kan simma, utan också flyga. Låt oss skriva flyggränssnittet och implementera det i vår anka.

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!!!");
   }

}

Och återigen är det viktigt att komma ihåg varför vi skriver gränssnittet. Låt oss säga att om det implementeras av en fågel, ett flygplan, en fallskärmshoppare och en maskros, kommer deras flygningar att vara helt annorlunda.