meningen med interface

Et interface er en kontrakt.

Når en klasse implementerer et interface så skriver den under på en kontrakt
om at den vil have nogle angive metoder.

Og compileren sørger for at kontrakten overholdes.

Pointen er den at du totalt adskiller interfacet fra implementationen.

Du tilføjer en action listener og Swing klasserne ved hvilken metode de
kan kalde. De ved intet om hvilken klasse det er fordi de bliver kaldt
med 10 millioner forskellige bruger klasser. Men det gør ikke noget fordi
de har en kontrakt på hvilken metode de kan stole på er tilstede.

Et andet eksempel - du laver:

public interface Store {
  public save(X x);
}

public class FileStore {
  public FileStore(String filename) {
      // open file
  }
  public save(X x) {
      // store x to file
  }
}

public class DatabaseStore {
  public DatabaseStore(String dburl, String usr, String pwd) {
      // open JDBC connection
  }
  public save(X x) {
      // store x to database
  }
}

så kan du overalt i din kode bruge en Store og kun et eneste sted
nemlig ved kald af constructor angive hvilken type Store det er:

Store stor = new FileStore("foobar.dat");

og kalde save metoden overalt i koden (fordi der er en kontrakt på at en
sådan metode eksisterer).

OK ?

Mangler der i ovenstående eksempel ikke at 'kontrakten' underskrives (implements Store).

Men hvad er ideen med at der underskrives en kontrakt, når den klasse der implementerer interfacet selv skal lave funktionaliteten for metoderne. Altså, hvad får den klasse der implementerer udover nogle metoder som den selv skal udbygge..?

Ups jo.

Jeg glemte sådan set det vigtigste.

public class FileStore implements Store {
  public FileStore(String filename) {
      // open file
  }
  public save(X x) {
      // store x to file
  }
}

public class DatabaseStore implements Store {
  public DatabaseStore(String dburl, String usr, String pwd) {
      // open JDBC connection
  }
  public save(X x) {
      // store x to database
  }
}

Pointen er at du kan skrive :

Store stor = new FileStore("foobar.dat");

og bruge stor som en Store uanset om det er den ene eller den anden
implementation.

Men hvorfor objektet 'Store'? Hvad er smart ved det frem for fx
FileStore stor = new FileStore("foobar.dat");

Fordi du så laver 1000 metoder hvor du opererer på Store og når din arkitekt kommer og
siger at du skal skifte fra FileStore til DatabaseStore, så retter du fra:

Store stor = new FileStore("foobar.dat");

til:

Store stor = new DatabaseStore("jdbc:xxx:xxx", "xxx", "xxx");

et enkelt sted.

I stedet for at skulle ind og rette fra FileStore til DatabaseStore i 1000 metoder !

Adskillelse af interface og implementation gør det nemmere at skifte
implementation.

Der var faktisk fanatikere der lige da Java kom frem som lavede et interface
for hver eneste klasse.

En anden måde at illustrere det på - ved bare ikke lige om det fremmer forståelsen

interface Animal{
    public String hvilkenArt();
}


class Cat implements Animal{
    public Cat(){
    }

    public String hvilkenArt() {
        return "er en kat";
    }
}


class Bird implements Animal{
    public Bird(){
    }

    public String hvilkenArt() {
        return "er en fugl";
    }
}

public class Zoo {
    public static void main(String[] args){
        Animal a;
       
        a = new Bird();
            System.out.println( "Class Bird " + a.hvilkenArt());
           
        a = new Cat();
        System.out.println("Class Cat " + a.hvilkenArt());
    }
}

Hej Arne,
tak for din hjælp, jeg tror det sidste eksempel hjalp mig til at forstå det. Tak for din hjælp.