Implementa in Java

Quando alcuni parlano del paradigma di ereditarietà Java OOP, di solito intendono estendere una classe genitore con un erede, una classe figlia. Tuttavia, quando incontri la parola chiave Java implements, significa che passiamo a un altro livello di astrazione e iniziamo a lavorare con le interfacce in Java. Parleremo di cosa sono le interfacce, a cosa servono, come avviene l'implementazione.

Che cos'è l'interfaccia e l'implementazione

Probabilmente hai sentito molte volte la parola "interfaccia". Ad esempio, un computer ha un'interfaccia di input (mouse e tastiera), molti programmi hanno interfacce utente. Nel senso più ampio, un'interfaccia è un collegamento tra due parti interagenti. Ad esempio, la stessa tastiera o telecomando TV. Nella programmazione, e in Java in particolare, un'interfaccia è un contratto specifico che dice cosa farà la classe che la implementa. Un'interfaccia definisce solo il comportamento. Non dice nulla sull'oggetto che lo implementerà. Puoi dichiarare un'interfaccia in Java in questo modo:

public interface MyInterface  {

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

Ecco una sintassi di Implements in Java:

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

Un'interfaccia descrive il comportamento senza specificarlo. Ad esempio, un comportamento come "movimento" può essere applicato a diversi tipi di oggetti: una bicicletta, una persona, un'auto, l'acqua di un fiume e così via. Il comportamento del nuoto può essere il comportamento di un'anatra, di una nave o di un pesce. Questi oggetti non hanno nulla in comune se non il fatto che possono muoversi o nuotare. Sì, e il movimento stesso con il nuoto sono molto diversi. Tuttavia, in Java puoi creare classi Duck , Boat , Fish e lasciare che implementino la capacità di nuotare. Qui è dove viene utilizzata la parola chiave Java Implements .

Esempio di parola chiave implementata

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

Come puoi vedere, i metodi stessi non sono implementati. Ma abbiamo dichiarato che le classi che implementano questa interfaccia devono essere in grado di nuotare in linea retta, oltre che di girare a destra ea sinistra. Creiamo classi che implementeranno questa interfaccia.

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

Tutte le classi che implementano l' interfaccia Swimmable , secondo il contratto, devono essere in grado di nuotare in avanti (implementare il metodo moveForward() ), così come girare a destra ea sinistra. È richiesta l'implementazione di questi metodi. Un'anatra e un pesce nuotano in modo diverso. Diciamo che un pesce ha due metodi aggiuntivi che implementano la sua capacità di nuotare su e giù. L'interfaccia Swimmable non ha questo. Tuttavia, se creiamo un figlio della classe Pesce, ad esempio Tonno o Salmone, anche lui, come ogni "Pesce", sarà in grado di nuotare su e giù.

Interfacce multiple in Java

Come probabilmente già saprai, Java non supporta l'ereditarietà multipla. Ciò significa che una classe può essere ereditata solo da una superclasse. Tuttavia, in un certo senso è ancora possibile utilizzare "ereditarietà multipla" in Java, poiché una classe può implementare più interfacce.

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

Esempio di interfacce multiple

Ricorda che un'anatra non solo può nuotare, ma anche volare. Scriviamo l'interfaccia di volo e implementiamola nella nostra anatra.

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

}

E ancora, è importante ricordare perché stiamo scrivendo l'interfaccia. Diciamo che se viene implementato da un uccello, un aeroplano, un paracadutista e un dente di leone, i loro voli saranno completamente diversi.