Une interface est un modèle d'implémentation, permettant de mettre en relation des entités sans rapports.

Dans le langage de programmation Java, une interface, définissant un protocole de comportement, est un élément que des objets sans liens utilisent pour interagir entre eux.

La déclaration d'une interface s'effectue par l'intermédiaire de l'instruction interface.

modificateur_acces interface NomInterface {
  //...
}

Une interface déclarée avec un modificateur d'accès public peut être implémentée par n'importe quelle classe intérieure ou extérieure à son paquetage. A défaut, elle ne pourra être utilisée que dans le paquetage parent.

Par ailleurs, toutes les interfaces portent implicitement le modificateur abstract.

Une interface peut être déclarée avec le modificateur strictfp permettant de contrôler le comportement de la virgule flottante.

Il ne peut exister qu'une seule et unique interface publique par fichier source, à l'instar des classes publiques. Par convention, une interface publique donne son nom au fichier source.

De plus, Java ne permettant pas l'héritage multiple, l'utilisation des interfaces permet de palier à cette carence dans la mesure où une classe peut désormais implémenter plusieurs interfaces.

L'instruction implements permet d'indiquer que la classe fournit une implémentation pour une ou plusieurs interfaces. Ce mot clé doit toujours être placé après la clause d'extension introduite par extends.

class NomClasse implements NomInterface, ..., NomInterfaceN {
  //...
}

Les interfaces possèdent en général dans leur bloc d'instructions, des déclaration de méthodes sans corps ainsi que des déclaration de variables.

// Déclaration de méthode
modificateur_acces Type nomMethode();
// Déclaration de variable
modificateur_acces Type nomVariable = ValeurConstante;

public interface ValidationEnvoi {
  final float TIMBRE = 0.46f;

  public void Poste(float timbre, String adr_exp);
  public boolean PossedeUnTimbre();
  public boolean PossedeUneAdressedExpedition();
  public boolean Envoi();
}

Toutes les méthodes contenues dans une interface sont implicitement déclarées publiques et abstraites.

Les méthodes ne peuvent être déclarées avec les modificateurs final, native, static, et synchronized.

Toutes les variables, en fait des constantes, contenues dans une interface sont implicitement déclarées publiques, statiques et finales et doivent avoir une valeur constante d'affectation.

Les constantes ne peuvent être déclarées avec les modificateurs transient et volatile.

Afin d'éviter une redondance dans les déclarations de méthodes et de constantes, il est inutile de spécifier explicitement les modificateurs par défaut précités.

Toutes les classes implémentant une interface doivent possèder les méthodes déclarées dans cette dernière en y ajoutant toutefois un bloc d'instructions.

public class Lettre implements ValidationEnvoi {
  int nb_timbres = 0;
  String adr_exp = null;
  boolean valide_timbre = false;
  boolean valide_adresse = false;

public void Poste(int timbre, String adr_exp) {
    this.nb_timbres = timbre;
    this.adr_exp = adr_exp;
    System.out.println("Timbre : " + this.timbre + "n" +
                        "Adresse : " + this.adr_exp);
  }

public boolean PossedeUnTimbre() {
    if (nb_timbres > 0)
      return valide_timbre = true;
    else
      return valide_timbre = false;
  }

  public boolean PossedeUneAdressedExpedition() {
    if (adr_exp != null)
      return valide_adresse = true;
    else
      return valide_adresse = false;
  }

  public boolean Envoi() {
    if (valide_timbre && valide_adresse)
      return true;
    else
      return false;
  }

  public float PrixTimbres() {
      return this.nb_timbres * TIMBRE;
  }
}
  
public class Appli {
  public static void main(String args[]) 
    String adresse = "Mlle Julie LAMYrn"
                   + "10 Allée d'Artoisrn"
                   + "93330 Neuilly Sur Marne";
    int affranchissement = 1;

    Lettre envoiLettre = new Lettre();

    envoiLettre.Poste(affranchissement, adresse);

    System.out.println("Adresse d'expedition : " +
        (envoiLettre.PossedeUneAdressedExpedition() ? "Oui" : "Non"));

    System.out.println("Affranchissement : " +
        (envoiLettre.PossedeUnTimbre() ? "Oui" : "Non"));

    System.out.println("Montant de l'affranchissement : " +
        envoiLettre.PrixTimbres() + " €");

    System.out.println("Procedure d'envoi validee : " +
        (envoiLettre.Envoi() ? "Oui" : "Non"));
  }
}

Les interfaces ne peuvent implémenter d'autres interfaces. Par contre, elles peuvent hériter de plusieurs autres interfaces.

public interface NomInterface 
              extends AutreInterface, ..., AutreInterface 
...

Le bloc d'instructions des interfaces contient essentiellement des déclarations de constantes et de méthodes abstraites.

Les interfaces constituent une catégorie particulière des classes abstraites.