Interface
Eine Schnittstelle ( in der Java-Terminologie: ein interface ) legt fest, welche Methoden vorhanden sein sollen, ohne die Methoden inhaltlich festzulegen. Dazu braucht man eine Klasse: Was diese Methoden konkret tun sollen, entscheidet die Klasse, durch die das interface implementiert wird. Eine Klasse, die ein interface implementiert, ist gezwungen alle Methoden des interface zu implementieren.

Wenn also mehrere Klassen ein und daselbe interface implementieren, dann besitzen sie alle die Methoden aus dem interface, und können diese bei Bedarf unterschiedlich implementieren.

Bsp.: 1 Interface

Als einfaches Beispiel kann man sich vorstellen: Berechnung von Fläche und Umfang unterschiedlicher geometrischer Figuren. Alle geometrischen Figuren wie z.B. Kreise und Rechtecke etc. haben Fläche und Umfang, jedoch ist die Art der Berechnung bei den verschiedenen Figuren unterschiedlich. Das einzige, was allen gemeinsam ist, ist die Notwendigkeit, irgendwie bestimmte Werte zu berechnen und unter einem einheitlichen Namen anzusprechen. Die ProgrammiererInnen, die mit geometrischen Figuren befasst sind, brauchen gewissermassen eine Garantie: jede geometrische Figur kann Fläche und Umfang berechnen.

Aus diesem Grund wird man als erstes das Interface folgendermassen definieren: 

public interface Geom
{
        public double flaeche();
        public double umfang();
}
Die Leistung des interface ist: alle btr. Klassen haben Eine Schnittstelle/ein interface wird also wie eine Klasse in einer .java-Datei definiert und diese Datei wird kompiliert wie eine Klassen-Datei. Die Definition der Schnittstelle beginnt mit dem Schlüsselwort interface

Die Klassen, welche diese Schnittstelle implementieren, werden gekennzeichnet durch das Schlüsselwort implements: 

public class Ellipse extends Kreis implements Geom
{
        //Def. der Klasse Ellipse,
        //im folgenden nicht ausgeführt
}
Damit hat diese Klasse die Verpflichtung, die Methoden des interface zu definieren.

Bsp.: 2 Klassen

Als Beispiel für implementierende Klassen folgen jetzt 2 Klassen: Kreis und Rechteck. Beide implementieren auf unterschiedliche Weise die Methoden des Interface ( dazu sind sie ja verpflichtet ).

Kreis.java 

public class Kreis implements Geom
{
        private double radius;

        public void  setzeRadius( double rad ){
                 radius = rad ;
        }
        public double flaeche(){
                return Math.PI * radius * radius;
        }
        public double leseRadius(){
                return radius;
        }
        public double umfang(){
               return 2*Math.PI*radius;
        }
}
Rechteck.java 
public class Rechteck implements Geom
{
      private double lang, breit;
      public void setLang( double lang ){
             this.lang = lang;
      }
      public void setBreit( double b ){
             breit = b;
      }
      public double getLang(){
             return lang;
      }
      public double getBreit(){
             return breit;
      }
       public double flaeche(){
              return lang*breit;
       }
       public double umfang(){
              return 2*(lang+breit);
       }
}
Somit ist sichergestellt, dass alle Objekte der Klassen Kreis und Rechteck ihre jeweiligen Flächen und Umfänge berechnen können.

Interessant ist dies vor allem für andere Klassen, die ihrerseits Kreis- oder Rechteck-Objekte benutzen.

Nutzanwendung

Ein Programm, das den Materialbedarf unterschiedlich geformter Objekte berechnet. Dieses Programm interessiert sich nicht dafür, wie die unterschiedliche Objekte ihre jeweiligen Fläche und Umfänge berechnen, sondern nur dafür, dass sie es überhaupt tun. Hier macht es sich bemerkbar, dass Klassen, die ein Interface implementieren, den Typ des Interface als zusätzliche Typ bekommen. Mit anderen Worten: Interfaces kann man als Parameter-DatenTyp einsetzen, siehe im folgenden Bsp. die Methoden
flaechenBedarf( Geom teil )
und
gesamtUmfang( Geom teil )

Materialbedarf.java 

public class MaterialBedarf
{
public static double flaechenBedarf( Geom teil ){
       return teil.flaeche();
}
public static double gesamtUmfang( Geom teil ){
       return teil.umfang();
}
static public void main(String[] args )
{
       Kreis kreis1 = new Kreis();
       kreis1.setzeRadius( 123.0 );
       Rechteck recht1 = new Rechteck();
       recht1.setLang( 12.0 );
       recht1.setBreit( 34.0 );
       System.out.println( "Kreis-Flaeche: "
                        + flaechenBedarf( kreis1 ));
       System.out.println( "Kreis-Umfang: "
                        + gesamtUmfang( kreis1 ));
       System.out.println( "Rechteck-Flaeche: "
                        + flaechenBedarf( recht1 ));
       System.out.println( "Rechteck-Umfang: "
                        + gesamtUmfang( recht1 ));
}
}
Das Programm bringt folgenden output: 
F:>java MaterialBedarf
Kreis-Flaeche: 47529.15525615998
Kreis-Umfang: 772.8317927830891
Rechteck-Flaeche: 408.0
Rechteck-Umfang: 92.0
Mehr: Ausführliches Interface-Bsp.