Interfețe

În timp ce clasele abstracte pot conține atât cod parțial implementat, cât și câmpuri de instanță, interfețele în Java sunt contracte de pur comportament. O interfață definește ce trebuie să poată face o clasă, dar nu cum o face.

Acest lucru permite decuplarea completă între definirea operațiunilor și implementarea lor efectivă.

Definirea unei interfețe (interface)

Folosim cuvântul cheie interface. Toate metodele declarate într-o interfață sunt implicit public și abstract (nu este nevoie să o specificați):

interface Drivable {
    void startEngine();
    void stopEngine();
}

Implementarea unei interfețe (implements)

O clasă implementează o interfață folosind cuvântul cheie implements și este necesară pentru a furniza implementarea (cu un corp) pentru toate metodele definite:

class Motorcycle implements Drivable {
    @Override
    public void startEngine() {
        System.out.println("Rombo del motore acceso!");
    }

    @Override
    public void stopEngine() {
        System.out.println("Motore spento.");
    }
}

Avantajele interfețelor

1. Moștenire multiplă: În Java, o clasă poate extinde _doar o clasă părinte (moștenire unică), dar poate implementa interfețe multiple în același timp. COD_PROTECTED_GARD_2
2. Decuplare: Puteți defini variabile folosind tipul de interfață. Orice obiect care implementează acea interfață poate fi atribuit unei astfel de variabile.
   Java

   Copiere

   Drivable vehicle = new Motorcycle();
   vehicle.startEngine();

Constante în interfețe

În interfețe, este posibil să se declare câmpuri. Aceste câmpuri sunt implicit public static final (adică constante de clasă), chiar dacă nu specificați acești modificatori. În consecință, acestea trebuie inițializate imediat după declarare:

interface PhysicsConstants {
    double GRAVITY = 9.81; // Implicitly public static final
}

Metode implicite (default)

Pornind de la Java 8, este posibil să se definească metode cu o implementare implicită în interiorul unei interfețe folosind cuvântul cheie default. Aceste metode nu forțează clasele de implementare să le suprascrie, oferind un comportament de rezervă:

interface Logger {
    void log(String message);

    // Default method with a body
    default void logError(String message) {
        log("ERROR: " + message);
    }
}

Încercați-l singur