Interfaccia in Java

Come sai, tutto in Java è costituito da oggetti e gli oggetti hanno uno stato (campi) e un comportamento (definito dai metodi). Il comportamento di una classe è ciò che può legarla ad altre classi. Il comportamento può avere caratteristiche diverse e talvolta può essere più conveniente spostarlo al di fuori della classe, soprattutto quando si tratta di interagire con il mondo esterno. Proprio come il telecomando della TV è fuori dalla “scatola” stessa. Il telecomando è un'interfaccia per l'interazione dell'utente con le funzioni del televisore. Ad esempio, puoi immaginare una classe che implementa un aereo o un elicottero astratto. Gli oggetti di entrambe le classi, come la maggior parte degli uccelli, possono volare e lo fanno tutti in modo diverso. Forse vale la pena spostare questa funzionalità in un'entità separata e tutti i potenziali "volantini" verranno ereditati da questa entità? Se hai già familiarità con le classi astratte, puoi semplicemente creare una classe astratta Flyable ed "ereditare" le classi Copter e Plane da essa. Tuttavia, cosa succede se esistono diverse proprietà di questo tipo? Ad esempio, aerei ed elicotteri possono volare, ma anche viaggiare a terra. Anche se creiamo la classe Ride, non possiamo più assegnarle Elicottero e Aereo. Dopotutto, ogni classe Java ha una sola classe genitore. L'utilizzo delle interfacce in linguaggio Java risolve parzialmente questo problema. Le interfacce in Java definiscono alcune funzionalità che non hanno un'implementazione specifica, che viene quindi implementata dalle classi che utilizzano queste interfacce. E una classe può implementare molte interfacce. Infatti, implementando un'interfaccia in Java, dichiariamo che la nostra classe può fare qualcosa, ne riportiamo il comportamento. Effettuiamo già l'attuazione concreta del comportamento in classe. COSÌ. un aereo e un elicottero decollano in modo diverso: un aereo ha bisogno di una pista, mentre un elicottero solitamente decolla verticalmente. Tali dettagli vengono implementati al meglio all'interno della classe.

Interfacce in Java

Per definire un'interfaccia in linguaggio Java, viene utilizzata la parola chiave Interface. Per esempio:

interface Voice {

    void talk();
}

L'interfaccia sopra si chiama Voce . Un'interfaccia in Java può definire costanti e metodi, che possono o meno avere implementazioni. Di solito, i metodi dell'interfaccia non hanno un'implementazione, proprio come in questo esempio. I metodi nelle interfacce senza implementazione sono come metodi astratti di classi astratte. I metodi di interfaccia di solito non hanno modificatori di accesso. Tuttavia l'accesso è in realtà pubblico per impostazione predefinita perché lo scopo di un'interfaccia è definire la funzionalità per l'implementazione di una classe. Pertanto, tutte le funzionalità dovrebbero essere aperte per l'implementazione. Per implementare un'interfaccia, usa la parola chiave Implements mentre dichiari la tua classe. Inoltre, se un'interfaccia contiene un metodo senza implementazione, quel metodo deve essere implementato nella classe di implementazione.

public class Duck implements Voice {


@Override
public void voice() {
   System.out.println("Quack");
}


    }

Esempio di codice di interfaccia

Facciamo un esempio più completo. Ogni (beh, quasi ogni) animale ha la capacità di emettere suoni. Creiamo un'interfaccia Java Voice per questo caso. Ha un metodo talk() senza implementazione.

public interface Voice {
   void talk();
}

Ora tutte le classi che supportano l' interfaccia Voice devono avere un'implementazione del metodo talk() . Creiamo due classi: Gatto e Cane e indichiamo che implementano l' interfaccia vocale . In questo caso, se non si implementa una classe al suo interno, il programma non funzionerà. I metodi di implementazione sono molto semplici. Quando si richiama il metodo talk() di un oggetto della classe Cat , sullo schermo verrà visualizzato l'equivalente testuale di un miagolio, nel caso della classe Dog di un abbaiare. Aggiungeremo anche getter, setter e un costruttore alle classi.

public class Cat implements Voice {
   String name;
   String breed;
   int year;

   public Cat(String name, String breed, int year) {
       this.name = name;
       this.breed = breed;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getBreed() {
       return breed;
   }

   public void setBreed(String breed) {
       this.breed = breed;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("meow...");
   }
}

public class Dog implements Voice {
   String name;
   String color;
   int year;

   public Dog(String name, String color, int year) {
       this.name = name;
       this.color = color;
       this.year = year;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       System.out.println("WOF WOF");
   }
}

In effetti, le nostre implementazioni di classi e metodi sono molto simili. Creiamo un'altra classe, Parrot , con supporto vocale . Solo il metodo talk() funzionerà diversamente: l'utente inserirà una stringa nella console e il pappagallo la “ripeterà” utilizzando il metodo talk() .

import java.util.Scanner;

public class Parrot implements Voice {
   String name;
   String color;
   int year;

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public String getColor() {
       return color;
   }

   public void setColor(String color) {
       this.color = color;
   }

   public int getYear() {
       return year;
   }

   public void setYear(int year) {
       this.year = year;
   }

   @Override
   public void talk() {
       Scanner scanner = new Scanner(System.in);
       System.out.println("WHat should I repeat after you?...");
       String s =  scanner.nextLine();
       System.out.println(s);
   }
}

Creiamo ora una classe di test e vediamo quale risultato produrrà il programma se chiameremo in sequenza il metodo talk() degli oggetti delle classi Cat , Dog e Parrot .

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Parrot parrot = new Parrot();
       parrot.talk();
   }
}

L'output è di seguito. Il testo verde è quello stampato dall'utente nella console.

Metodi predefiniti

Prima del rilascio di JDK 8, quando implementavamo un'interfaccia in Java, dovevamo implementare tutti i suoi metodi in una classe. Allo stesso tempo, l'interfaccia Java stessa potrebbe contenere solo definizioni di metodi senza un'implementazione specifica. JDK 8 aggiunge nuove funzionalità: metodi predefiniti. Ora le interfacce Java possono avere non solo definizioni di metodi ma anche implementazioni predefinite. Vengono utilizzati se la classe implementa l'interfaccia ma non implementa il metodo. Ad esempio, cambiamo il metodo talk() nell'interfaccia vocale con il metodo predefinito. Scriveremo anche una nuova classe Duck abilitata per la voce che non ha un'implementazione del metodo talk .

public interface Voice {
   default void talk() {
       System.out.println("I can talk...");
   }
}

public class Duck implements Voice {

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

}

Ora cambiamo un po' la nostra classe di test.

public class InterfaceDemo {
   public static void main(String[] args) {
       Cat cat = new Cat ("Mewie", "Siam" ,2021);
       cat.talk();
       Dog dog = new Dog("Snoopy", "White and black", 2020);
       dog.talk();
       Duck duck = new Duck();
       duck.talk();
   }
}

L'output è qui: Vedere? Negli oggetti delle classi Dog e Cat viene richiamato il metodo sovrascritto talk() , ma in un oggetto della classe Duck viene richiamato il metodo predefinito dell'interfaccia. Pertanto, il metodo predefinito è semplicemente un metodo senza modificatori ed è contrassegnato con la parola chiave predefinita. Non dobbiamo implementare il metodo predefinito nella classe che implementa l'interfaccia, ma possiamo sovrascriverlo.

Metodi statici

Poiché i metodi statici JDK 8 sono disponibili nelle interfacce Java, sono simili ai metodi di classe:

interface Voice {

    void talk();

    static void check(){

        System.out.println("checked...");
    }
}

Per fare riferimento ad un metodo statico di un'interfaccia, proprio come nel caso delle classi, scrivere il nome dell'interfaccia e del metodo:

public static void main(String[] args) {

    Voice.check();
}

Implementazione multipla di interfacce

Se dobbiamo applicare diverse interfacce nella classe Java, saranno tutte elencate con una virgola dopo la parola implements :

public class Duck implements Swimmable, Flyable, Voice {

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

}