Metodi predefiniti nelle interfacce

Ogni nuova versione di Java differisce da quelle precedenti. Ecco un esempio dei cambiamenti nel materiale che abbiamo trattato: prima di Java 5, il linguaggio non aveva enums. Allo stesso modo, Java 8 differisce notevolmente da Java 7. La maggior parte delle nostre lezioni sono state scritte per la settima versione del linguaggio, ma ovviamente non ignoreremo importanti innovazioni. Dato che in questa lezione stiamo già parlando di interfacce, prenderemo in considerazione un aggiornamento: metodi predefiniti in interfaces . Sai già che un'interfaccia non implementa behavior . Il suo compito è descrivere il comportamento che devono avere tutti gli oggetti che lo implementano. Ma gli sviluppatori hanno spesso riscontrato situazioni in cui l'implementazione di un metodo è la stessa in tutte le classi. Consideriamo il nostro vecchio esempio di auto:

public interface Car {

   public void gas();

   public void brake();
}
public class Sedan implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class Truck implements Car {

   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}


public class F1Car implements Car {
   @Override
   public void gas() {
       System.out.println("Gas!");
   }

   @Override
   public void brake() {
       System.out.println("Brake!");
   }
}

"Secondo te, qual è il problema principale di questo codice? Probabilmente avrai notato che abbiamo scritto un sacco di codice ripetuto! Questo problema è comune nella programmazione e devi evitarlo. È un'altra questione che prima non esistevano soluzioni particolari È stato rilasciato Java 8. Con questa versione è arrivata la possibilità di specificare metodi predefiniti e implementarli direttamente all'interno dell'interfaccia! Ecco come si fa:

public interface Car {

   public default void gas() {
       System.out.println("Gas!");
   }

   public default void brake() {
       System.out.println("Brake!");
   }
}

public class Sedan implements Car {

}

public class Truck implements Car {

}

public class F1Car implements Car {

}

Ora i metodi gas()e brake(), uguali per tutte le auto, sono stati spostati nell'interfaccia. Non è necessario alcun codice ripetuto. Inoltre, i metodi sono disponibili in ogni classe!

public class Main {

   public static void main(String[] args) {

       F1Car f1Car = new F1Car();
       Sedan sedan = new Sedan();
       Truck truck = new Truck();
       truck.gas();
       sedan.gas();
       f1Car.brake();
   }
}

Cosa succede se ci sono 100 classi con il gas()metodo, ma solo 99 di esse hanno lo stesso comportamento? Ciò rovina tutto e rende il metodo predefinito inadatto a questa situazione? Certo che no :) I metodi predefiniti nelle interfacce possono essere sovrascritti allo stesso modo di quelli ordinari.

public class UnusualCar implements Car {
   @Override
   public void gas() {
       System.out.println("This car accelerates differently!");
   }

   @Override
   public void brake() {
       System.out.println("This car decelerates differently!");
   }
}

Tutti gli altri 99 tipi di auto implementeranno il metodo predefinito e ilUnusualCarla classe, che è un'eccezione, non rovina il quadro generale e definisce con calma il proprio comportamento. Ereditarietà multipla delle interfacce. Come già sai, Java non supporta l'ereditarietà multipla. Ci sono molte ragioni per questo. Li esamineremo in dettaglio in una lezione separata. Altri linguaggi, come C++, lo supportano. Senza ereditarietà multipla, sorge un problema serio: un oggetto può avere diverse caratteristiche e "comportamenti". Ecco un esempio dalla vita: siamo bambini per i nostri genitori, studenti per i nostri insegnanti e pazienti per i nostri dottori. Nella vita assumiamo ruoli diversi e, di conseguenza, ci comportiamo in modo diverso: ovviamente, non parleremmo con gli insegnanti nello stesso modo in cui parliamo con i nostri amici più cari. Proviamo a tradurre questo in codice. Immaginiamo di avere due classi: Stagno e voliera. Per lo stagno abbiamo bisogno di uccelli acquatici; per la voliera, abbiamo bisogno di uccelli volanti. Per fare ciò, abbiamo creato due classi base:FlyingBirde Waterfowl.

public class Waterfowl {
}

public class FlyingBird {
}

Di conseguenza, invieremo gli uccelli le cui classi ereditano FlyingBirdalla voliera e invieremo gli uccelli che ereditano Waterfowlallo stagno. Sembra tutto molto semplice. Ma dove mandiamo un'anatra? Nuota e vola. E non abbiamo ereditarietà multiple. Fortunatamente, Java supporta l'implementazione multipla delle interfacce. Sebbene una classe non possa ereditare più genitori, può facilmente implementare diverse interfacce! La nostra anatra può essere sia un uccello volante che un uccello acquatico :) Abbiamo semplicemente bisogno di creare FlyingBirdinterfacce Waterfowlpiuttosto che classi per ottenere il risultato desiderato.

public class Duck implements FlyingBird, Waterfowl {

   // The methods of both interfaces can be easily combined into one class

   @Override
   public void fly() {
       System.out.println("Fly!");
   }

   @Override
   public void swim() {

       System.out.println("Swim!");
   }
}

Di conseguenza, il nostro programma mantiene la flessibilità delle classi e, in combinazione con metodi predefiniti, la nostra capacità di definire il comportamento degli oggetti diventa quasi illimitata! :)